GNU Emacs Lisp 参考文档

Emacs Lisp

这是GNU Emacs Lisp参考文档的3.0版本，对应于Emacs23.3版本。

由张东亚汉化，汉化版本为0.9。

更新记录：

2011/06/22：启动第二章的翻译，待完成。 2011/07/02：完成第二章的翻译。

Copyright © 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “GNU General Public License,” with the Front-Cover texts being “A GNU Manual,” and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License.”

(a) The FSF's Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.”

• 介绍: 介绍以及惯例
• Lisp数据类型: Emacs Lisp中的数据类型。
• Numbers: Numbers and arithmetic functions.
• Strings and Characters: Strings, and functions that work on them.
• Lists: Lists, cons cells, and related functions.
• Sequences Arrays Vectors: Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
• Hash Tables: Very fast lookup-tables.
• Symbols: Symbols represent names, uniquely.
• Evaluation: How Lisp expressions are evaluated.
• Control Structures: Conditionals, loops, nonlocal exits.
• Variables: Using symbols in programs to stand for values.
• Functions: A function is a Lisp program that can be invoked from other functions.
• Macros: Macros are a way to extend the Lisp language.
• Customization: Writing customization declarations.
• Loading: Reading files of Lisp code into Lisp.
• Byte Compilation: Compilation makes programs run faster.
• Advising Functions: Adding to the definition of a function.
• Debugging: Tools and tips for debugging Lisp programs.
• Read and Print: Converting Lisp objects to text and back.
• Minibuffers: Using the minibuffer to read input.
• Command Loop: How the editor command loop works, and how you can call its subroutines.
• Keymaps: Defining the bindings from keys to commands.
• Modes: Defining major and minor modes.
• Documentation: Writing and using documentation strings.
• Files: Accessing files.
• Backups and Auto-Saving: Controlling how backups and auto-save files are made.
• Buffers: Creating and using buffer objects.
• Windows: Manipulating windows and displaying buffers.
• Frames: Making multiple system-level windows.
• Positions: Buffer positions and motion functions.
• Markers: Markers represent positions and update automatically when the text is changed.
• Text: Examining and changing text in buffers.
• Non-ASCII Characters: Non-ASCII text in buffers and strings.
• Searching and Matching: Searching buffers for strings or regexps.
• Syntax Tables: The syntax table controls word and list parsing.
• Abbrevs: How Abbrev mode works, and its data structures.
• Processes: Running and communicating with subprocesses.
• Display: Features for controlling the screen display.
• System Interface: Getting the user id, system type, environment variables, and other such things.

Appendices

• Antinews: Info for users downgrading to Emacs 22.
• GNU Free Documentation License: The license for this documentation.
• GPL: Conditions for copying and changing GNU Emacs.
• Tips: Advice and coding conventions for Emacs Lisp.
• GNU Emacs Internals: Building and dumping Emacs; internal data structures.
• Standard Errors: List of all error symbols.
• Standard Buffer-Local Variables List of variables buffer-local in all buffers.
• Standard Keymaps: List of standard keymaps.
• Standard Hooks: List of standard hook variables.
• Index: Index including concepts, functions, variables, and other terms.

--- 下列详细章节 --- ---------------------------------

这些章节是上面列出章节的子节，这里列出以便于你可以直接查阅。

• 注意事项: 注意事项以及缺陷说明。
• Lisp历史: Emacs Lisp派生自MacLisp。
• 惯例: 本参考文档的内容格式说明。
• 版本信息: Emacs版本信息。
• 致谢: 作者、编辑者以及赞助者信息。

惯例

• 一些名词: 介绍本文档所用名词。
• nil和t: 符号nil和t如何使用。
• 求值记法: 求值记法格式说明。
• 打印记法: 示例代码输出结果格式说明。
• 错误信息: 错误信息格式说明。
• 缓冲区文本记法: 缓冲区文本格式说明。
• 描述信息格式: 函数、变量等描述信息格式说明。

描述信息格式

• 函数描述示例: 虚构函数foo描述说明。
• 变量描述示例: 虚构变量electric-future-map描述说明。

Lisp数据类型

• 打印表示: Lisp对象如何以文本形式进行表示。
• 注释: 注释及其格式惯例。
• 编程类型: 所有Lisp系统中出现的类型。
• 编辑类型: Emacs特定的类型。
• 循环对象: 循环结构的读取语法。
• 类型判定: 关于类型的验证函数。
• 相等判定: 任何两个对象的相等验证函数。

编程类型

• 整数类型: 不包含分数部分的数字。
• 浮点类型: 包含分数部分的数字，具有更大的值域。
• 字符类型: 字母、数字以及控制字符的表示。
• 符号类型: 多用途的对象，用于引用函数、变量或者属性表，具有唯一的标识。
• 序列类型: 表和数组都被归为序列。
• Cons Cell类型: Cons cells,和表(由Cons cell组成)。
• 数组类型: 数据包括字符串和容器。
• 字符串类型: 有效的字符数组。
• 容器类型: 一维数组。
• 字符表类型: 由字符索引的稀松一维数组。
• 布尔容器类型: 由t或nil组成的一维数组。
• 哈希表类型: 超快的查找表。
• 函数类型: 一块被调用的可执行代码。
• 宏类型: 用于将表达式展开成另外一个更基本但不美观的表达式的方法。
• 原始函数类型: 由C语言写成的函数，在Lisp程序中调用。
• 字节码类型: Lisp写成的函数，编译后的对象。
• 自动加载类型: 自动加载较少使用的函数。

字符类型

• 基本字符语法: 一般字符的语法。
• 一般转义语法: 如何使用编码表示字符。
• Ctl-字符语法: Ctl-字符语法。
• Meta-字符语法: Meta-字符语法。
• 其他字符修饰位: hyper-字符、 super-字符、 以及alt-字符语法。

Cons Cell和表类型

• 盒子图解: 对表进行图示。
• 点对记法: cons cells的常见语法。
• 关联表类型: 一种特殊构造的表。

字符串类型

• 字符串语法: 如何指定字符串。
• 字符串中的非ASCII字符: 字符串中的国际化字符。
• 非打印字符: 字符串中不可打印的字符。
• 文本属性和字符串: 具有文本属性的字符。

编辑类型

• 缓冲区类型: 编辑的基本对象。
• 标记类型: 缓冲区的一个位置。
• 窗口类型: 缓冲区在窗口中显示。
• 框类型: 窗口分割框。
• 终端类型: 显示框的终端设备。
• 窗口配置类型: 记录框的分割方式。
• 框配置类型: 记录所有框的状态。
• 进程类型: Emacs的子进程，进行在所属OS上。
• 流类型: 接收或发送字符。
• 按键映射类型: 按键发生时，哪个函数被调用。
• 覆盖类型: 覆盖如何表示。
• 字体类型: 用于显示文本的字体。

Numbers

• Integer Basics: Representation and range of integers.
• Float Basics: Representation and range of floating point.
• Predicates on Numbers: Testing for numbers.
• Comparison of Numbers: Equality and inequality predicates.
• Numeric Conversions: Converting float to integer and vice versa.
• Arithmetic Operations: How to add, subtract, multiply and divide.
• Rounding Operations: Explicitly rounding floating point numbers.
• Bitwise Operations: Logical and, or, not, shifting.
• Math Functions: Trig, exponential and logarithmic functions.
• Random Numbers: Obtaining random integers, predictable or not.

Strings and Characters

• String Basics: Basic properties of strings and characters.
• Predicates for Strings: Testing whether an object is a string or char.
• Creating Strings: Functions to allocate new strings.
• Modifying Strings: Altering the contents of an existing string.
• Text Comparison: Comparing characters or strings.
• String Conversion: Converting to and from characters and strings.
• Formatting Strings: format: Emacs's analogue of printf.
• Case Conversion: Case conversion functions.
• Case Tables: Customizing case conversion.

Lists

• Cons Cells: How lists are made out of cons cells.
• List-related Predicates: Is this object a list? Comparing two lists.
• List Elements: Extracting the pieces of a list.
• Building Lists: Creating list structure.
• List Variables: Modifying lists stored in variables.
• Modifying Lists: Storing new pieces into an existing list.
• Sets And Lists: A list can represent a finite mathematical set.
• Association Lists: A list can represent a finite relation or mapping.
• Rings: Managing a fixed-size ring of objects.

Modifying Existing List Structure

• Setcar: Replacing an element in a list.
• Setcdr: Replacing part of the list backbone. This can be used to remove or add elements.
• Rearrangement: Reordering the elements in a list; combining lists.

Sequences, Arrays, and Vectors

• Sequence Functions: Functions that accept any kind of sequence.
• Arrays: Characteristics of arrays in Emacs Lisp.
• Array Functions: Functions specifically for arrays.
• Vectors: Special characteristics of Emacs Lisp vectors.
• Vector Functions: Functions specifically for vectors.
• Char-Tables: How to work with char-tables.
• Bool-Vectors: How to work with bool-vectors.

Hash Tables

• Creating Hash: Functions to create hash tables.
• Hash Access: Reading and writing the hash table contents.
• Defining Hash: Defining new comparison methods.
• Other Hash: Miscellaneous.

Symbols

• Symbol Components: Symbols have names, values, function definitions and property lists.
• Definitions: A definition says how a symbol will be used.
• Creating Symbols: How symbols are kept unique.
• Property Lists: Each symbol has a property list for recording miscellaneous information.

Property Lists

• Plists and Alists: Comparison of the advantages of property lists and association lists.
• Symbol Plists: Functions to access symbols' property lists.
• Other Plists: Accessing property lists stored elsewhere.

Evaluation

• Intro Eval: Evaluation in the scheme of things.
• Forms: How various sorts of objects are evaluated.
• Quoting: Avoiding evaluation (to put constants in the program).
• Eval: How to invoke the Lisp interpreter explicitly.

Kinds of Forms

• Self-Evaluating Forms: Forms that evaluate to themselves.
• Symbol Forms: Symbols evaluate as variables.
• Classifying Lists: How to distinguish various sorts of list forms.
• Function Indirection: When a symbol appears as the car of a list, we find the real function via the symbol.
• Function Forms: Forms that call functions.
• Macro Forms: Forms that call macros.
• Special Forms: "Special forms" are idiosyncratic primitives, most of them extremely important.
• Autoloading: Functions set up to load files containing their real definitions.

Control Structures

• Sequencing: Evaluation in textual order.
• Conditionals: if, cond, when, unless.
• Combining Conditions: and, or, not.
• Iteration: while loops.
• Nonlocal Exits: Jumping out of a sequence.

Nonlocal Exits

• Catch and Throw: Nonlocal exits for the program's own purposes.
• Examples of Catch: Showing how such nonlocal exits can be written.
• Errors: How errors are signaled and handled.
• Cleanups: Arranging to run a cleanup form if an error happens.

Errors

• Signaling Errors: How to report an error.
• Processing of Errors: What Emacs does when you report an error.
• Handling Errors: How you can trap errors and continue execution.
• Error Symbols: How errors are classified for trapping them.

Variables

• Global Variables: Variable values that exist permanently, everywhere.
• Constant Variables: Certain "variables" have values that never change.
• Local Variables: Variable values that exist only temporarily.
• Void Variables: Symbols that lack values.
• Defining Variables: A definition says a symbol is used as a variable.
• Tips for Defining: Things you should think about when you define a variable.
• Accessing Variables: Examining values of variables whose names are known only at run time.
• Setting Variables: Storing new values in variables.
• Variable Scoping: How Lisp chooses among local and global values.
• Buffer-Local Variables: Variable values in effect only in one buffer.
• File Local Variables: Handling local variable lists in files.
• Directory Local Variables: Local variables common to all files in a directory.
• Frame-Local Variables: Frame-local bindings for variables.
• Variable Aliases: Variables that are aliases for other variables.
• Variables with Restricted Values: Non-constant variables whose value can not be an arbitrary Lisp object.

Scoping Rules for Variable Bindings

• Scope: Scope means where in the program a value is visible. Comparison with other languages.
• Extent: Extent means how long in time a value exists.
• Impl of Scope: Two ways to implement dynamic scoping.
• Using Scoping: How to use dynamic scoping carefully and avoid problems.

Buffer-Local Variables

• Intro to Buffer-Local: Introduction and concepts.
• Creating Buffer-Local: Creating and destroying buffer-local bindings.
• Default Value: The default value is seen in buffers that don't have their own buffer-local values.

Functions

• What Is a Function: Lisp functions vs. primitives; terminology.
• Lambda Expressions: How functions are expressed as Lisp objects.
• Function Names: A symbol can serve as the name of a function.
• Defining Functions: Lisp expressions for defining functions.
• Calling Functions: How to use an existing function.
• Mapping Functions: Applying a function to each element of a list, etc.
• Anonymous Functions: Lambda expressions are functions with no names.
• Function Cells: Accessing or setting the function definition of a symbol.
• Obsolete Functions: Declaring functions obsolete.
• Inline Functions: Defining functions that the compiler will open code.
• Declaring Functions: Telling the compiler that a function is defined.
• Function Safety: Determining whether a function is safe to call.
• Related Topics: Cross-references to specific Lisp primitives that have a special bearing on how functions work.

Lambda Expressions

• Lambda Components: The parts of a lambda expression.
• Simple Lambda: A simple example.
• Argument List: Details and special features of argument lists.
• Function Documentation: How to put documentation in a function.

Macros

• Simple Macro: A basic example.
• Expansion: How, when and why macros are expanded.
• Compiling Macros: How macros are expanded by the compiler.
• Defining Macros: How to write a macro definition.
• Backquote: Easier construction of list structure.
• Problems with Macros: Don't evaluate the macro arguments too many times. Don't hide the user's variables.
• Indenting Macros: Specifying how to indent macro calls.

Common Problems Using Macros

• Wrong Time: Do the work in the expansion, not in the macro.
• Argument Evaluation: The expansion should evaluate each macro arg once.
• Surprising Local Vars: Local variable bindings in the expansion require special care.
• Eval During Expansion: Don't evaluate them; put them in the expansion.
• Repeated Expansion: Avoid depending on how many times expansion is done.

Writing Customization Definitions

• Common Keywords: Common keyword arguments for all kinds of customization declarations.
• Group Definitions: Writing customization group definitions.
• Variable Definitions: Declaring user options.
• Customization Types: Specifying the type of a user option.

Customization Types

• Simple Types: Simple customization types: sexp, integer, number, string, file, directory, alist.
• Composite Types: Build new types from other types or data.
• Splicing into Lists: Splice elements into list with :inline.
• Type Keywords: Keyword-argument pairs in a customization type.
• Defining New Types: Give your type a name.

Loading

• How Programs Do Loading: The load function and others.
• Load Suffixes: Details about the suffixes that load tries.
• Library Search: Finding a library to load.
• Loading Non-ASCII: Non-ASCII characters in Emacs Lisp files.
• Autoload: Setting up a function to autoload.
• Repeated Loading: Precautions about loading a file twice.
• Named Features: Loading a library if it isn't already loaded.
• Where Defined: Finding which file defined a certain symbol.
• Unloading: How to "unload" a library that was loaded.
• Hooks for Loading: Providing code to be run when particular libraries are loaded.

Byte Compilation

• Speed of Byte-Code: An example of speedup from byte compilation.
• Compilation Functions: Byte compilation functions.
• Docs and Compilation: Dynamic loading of documentation strings.
• Dynamic Loading: Dynamic loading of individual functions.
• Eval During Compile: Code to be evaluated when you compile.
• Compiler Errors: Handling compiler error messages.
• Byte-Code Objects: The data type used for byte-compiled functions.
• Disassembly: Disassembling byte-code; how to read byte-code.

Advising Emacs Lisp Functions

• Simple Advice: A simple example to explain the basics of advice.
• Defining Advice: Detailed description of defadvice.
• Around-Advice: Wrapping advice around a function's definition.
• Computed Advice: ...is to defadvice as fset is to defun.
• Activation of Advice: Advice doesn't do anything until you activate it.
• Enabling Advice: You can enable or disable each piece of advice.
• Preactivation: Preactivation is a way of speeding up the loading of compiled advice.
• Argument Access in Advice: How advice can access the function's arguments.
• Advising Primitives: Accessing arguments when advising a primitive.
• Combined Definition: How advice is implemented.

Debugging Lisp Programs

• Debugger: How the Emacs Lisp debugger is implemented.
• Edebug: A source-level Emacs Lisp debugger.
• Syntax Errors: How to find syntax errors.
• Test Coverage: Ensuring you have tested all branches in your code.
• Compilation Errors: How to find errors that show up in byte compilation.

The Lisp Debugger

• Error Debugging: Entering the debugger when an error happens.
• Infinite Loops: Stopping and debugging a program that doesn't exit.
• Function Debugging: Entering it when a certain function is called.
• Explicit Debug: Entering it at a certain point in the program.
• Using Debugger: What the debugger does; what you see while in it.
• Debugger Commands: Commands used while in the debugger.
• Invoking the Debugger: How to call the function debug.
• Internals of Debugger: Subroutines of the debugger, and global variables.

Edebug

• Using Edebug: Introduction to use of Edebug.
• Instrumenting: You must instrument your code in order to debug it with Edebug.
• Edebug Execution Modes: Execution modes, stopping more or less often.
• Jumping: Commands to jump to a specified place.
• Edebug Misc: Miscellaneous commands.
• Breaks: Setting breakpoints to make the program stop.
• Trapping Errors: Trapping errors with Edebug.
• Edebug Views: Views inside and outside of Edebug.
• Edebug Eval: Evaluating expressions within Edebug.
• Eval List: Expressions whose values are displayed each time you enter Edebug.
• Printing in Edebug: Customization of printing.
• Trace Buffer: How to produce trace output in a buffer.
• Coverage Testing: How to test evaluation coverage.
• The Outside Context: Data that Edebug saves and restores.
• Edebug and Macros: Specifying how to handle macro calls.
• Edebug Options: Option variables for customizing Edebug.

Breaks

• Breakpoints: Breakpoints at stop points.
• Global Break Condition: Breaking on an event.
• Source Breakpoints: Embedding breakpoints in source code.

The Outside Context

• Checking Whether to Stop: When Edebug decides what to do.
• Edebug Display Update: When Edebug updates the display.
• Edebug Recursive Edit: When Edebug stops execution.

Edebug and Macros

• Instrumenting Macro Calls: The basic problem.
• Specification List: How to specify complex patterns of evaluation.
• Backtracking: What Edebug does when matching fails.
• Specification Examples: To help understand specifications.

Debugging Invalid Lisp Syntax

• Excess Open: How to find a spurious open paren or missing close.
• Excess Close: How to find a spurious close paren or missing open.

Reading and Printing Lisp Objects

• Streams Intro: Overview of streams, reading and printing.
• Input Streams: Various data types that can be used as input streams.
• Input Functions: Functions to read Lisp objects from text.
• Output Streams: Various data types that can be used as output streams.
• Output Functions: Functions to print Lisp objects as text.
• Output Variables: Variables that control what the printing functions do.

Minibuffers

• Intro to Minibuffers: Basic information about minibuffers.
• Text from Minibuffer: How to read a straight text string.
• Object from Minibuffer: How to read a Lisp object or expression.
• Minibuffer History: Recording previous minibuffer inputs so the user can reuse them.
• Initial Input: Specifying initial contents for the minibuffer.
• Completion: How to invoke and customize completion.
• Yes-or-No Queries: Asking a question with a simple answer.
• Multiple Queries: Asking a series of similar questions.
• Reading a Password: Reading a password from the terminal.
• Minibuffer Commands: Commands used as key bindings in minibuffers.
• Minibuffer Contents: How such commands access the minibuffer text.
• Minibuffer Windows: Operating on the special minibuffer windows.
• Recursive Mini: Whether recursive entry to minibuffer is allowed.
• Minibuffer Misc: Various customization hooks and variables.

Completion

• Basic Completion: Low-level functions for completing strings.
• Minibuffer Completion: Invoking the minibuffer with completion.
• Completion Commands: Minibuffer commands that do completion.
• High-Level Completion: Convenient special cases of completion (reading buffer name, file name, etc.).
• Reading File Names: Using completion to read file names and shell commands.
• Completion Styles: Specifying rules for performing completion.
• Programmed Completion: Writing your own completion-function.

Command Loop

• Command Overview: How the command loop reads commands.
• Defining Commands: Specifying how a function should read arguments.
• Interactive Call: Calling a command, so that it will read arguments.
• Distinguish Interactive: Making a command distinguish interactive calls.
• Command Loop Info: Variables set by the command loop for you to examine.
• Adjusting Point: Adjustment of point after a command.
• Input Events: What input looks like when you read it.
• Reading Input: How to read input events from the keyboard or mouse.
• Special Events: Events processed immediately and individually.
• Waiting: Waiting for user input or elapsed time.
• Quitting: How C-g works. How to catch or defer quitting.
• Prefix Command Arguments: How the commands to set prefix args work.
• Recursive Editing: Entering a recursive edit, and why you usually shouldn't.
• Disabling Commands: How the command loop handles disabled commands.
• Command History: How the command history is set up, and how accessed.
• Keyboard Macros: How keyboard macros are implemented.

Defining Commands

• Using Interactive: General rules for interactive.
• Interactive Codes: The standard letter-codes for reading arguments in various ways.
• Interactive Examples: Examples of how to read interactive arguments.

Input Events

• Keyboard Events: Ordinary characters--keys with symbols on them.
• Function Keys: Function keys--keys with names, not symbols.
• Mouse Events: Overview of mouse events.
• Click Events: Pushing and releasing a mouse button.
• Drag Events: Moving the mouse before releasing the button.
• Button-Down Events: A button was pushed and not yet released.
• Repeat Events: Double and triple click (or drag, or down).
• Motion Events: Just moving the mouse, not pushing a button.
• Focus Events: Moving the mouse between frames.
• Misc Events: Other events the system can generate.
• Event Examples: Examples of the lists for mouse events.
• Classifying Events: Finding the modifier keys in an event symbol. Event types.
• Accessing Mouse: Functions to extract info from mouse events.
• Accessing Scroll: Functions to get info from scroll bar events.
• Strings of Events: Special considerations for putting keyboard character events in a string.

Reading Input

• Key Sequence Input: How to read one key sequence.
• Reading One Event: How to read just one event.
• Event Mod: How Emacs modifies events as they are read.
• Invoking the Input Method: How reading an event uses the input method.
• Quoted Character Input: Asking the user to specify a character.
• Event Input Misc: How to reread or throw away input events.

Keymaps

• Key Sequences: Key sequences as Lisp objects.
• Keymap Basics: Basic concepts of keymaps.
• Format of Keymaps: What a keymap looks like as a Lisp object.
• Creating Keymaps: Functions to create and copy keymaps.
• Inheritance and Keymaps: How one keymap can inherit the bindings of another keymap.
• Prefix Keys: Defining a key with a keymap as its definition.
• Active Keymaps: How Emacs searches the active keymaps for a key binding.
• Searching Keymaps: A pseudo-Lisp summary of searching active maps.
• Controlling Active Maps: Each buffer has a local keymap to override the standard (global) bindings. A minor mode can also override them.
• Key Lookup: Finding a key's binding in one keymap.
• Functions for Key Lookup: How to request key lookup.
• Changing Key Bindings: Redefining a key in a keymap.
• Remapping Commands: A keymap can translate one command to another.
• Translation Keymaps: Keymaps for translating sequences of events.
• Key Binding Commands: Interactive interfaces for redefining keys.
• Scanning Keymaps: Looking through all keymaps, for printing help.
• Menu Keymaps: Defining a menu as a keymap.

Menu Keymaps

• Defining Menus: How to make a keymap that defines a menu.
• Mouse Menus: How users actuate the menu with the mouse.
• Keyboard Menus: How users actuate the menu with the keyboard.
• Menu Example: Making a simple menu.
• Menu Bar: How to customize the menu bar.
• Tool Bar: A tool bar is a row of images.
• Modifying Menus: How to add new items to a menu.

Defining Menus

• Simple Menu Items: A simple kind of menu key binding, limited in capabilities.
• Extended Menu Items: More powerful menu item definitions let you specify keywords to enable various features.
• Menu Separators: Drawing a horizontal line through a menu.
• Alias Menu Items: Using command aliases in menu items.

Major and Minor Modes

• Hooks: How to use hooks; how to write code that provides hooks.
• Major Modes: Defining major modes.
• Minor Modes: Defining minor modes.
• Mode Line Format: Customizing the text that appears in the mode line.
• Imenu: How a mode can provide a menu of definitions in the buffer.
• Font Lock Mode: How modes can highlight text according to syntax.
• Desktop Save Mode: How modes can have buffer state saved between Emacs sessions.

Hooks

• Running Hooks: How to run a hook.
• Setting Hooks: How to put functions on a hook, or remove them.

Major Modes

• Major Mode Basics
• Major Mode Conventions: Coding conventions for keymaps, etc.
• Auto Major Mode: How Emacs chooses the major mode automatically.
• Mode Help: Finding out how to use a mode.
• Derived Modes: Defining a new major mode based on another major mode.
• Generic Modes: Defining a simple major mode that supports comment syntax and Font Lock mode.
• Mode Hooks: Hooks run at the end of major mode functions.
• Example Major Modes: Text mode and Lisp modes.

Minor Modes

• Minor Mode Conventions: Tips for writing a minor mode.
• Keymaps and Minor Modes: How a minor mode can have its own keymap.
• Defining Minor Modes: A convenient facility for defining minor modes.

Mode Line Format

• Mode Line Basics: Basic ideas of mode line control.
• Mode Line Data: The data structure that controls the mode line.
• Mode Line Top: The top level variable, mode-line-format.
• Mode Line Variables: Variables used in that data structure.
• %-Constructs: Putting information into a mode line.
• Properties in Mode: Using text properties in the mode line.
• Header Lines: Like a mode line, but at the top.
• Emulating Mode Line: Formatting text as the mode line would.

Font Lock Mode

• Font Lock Basics: Overview of customizing Font Lock.
• Search-based Fontification: Fontification based on regexps.
• Customizing Keywords: Customizing search-based fontification.
• Other Font Lock Variables: Additional customization facilities.
• Levels of Font Lock: Each mode can define alternative levels so that the user can select more or less.
• Precalculated Fontification: How Lisp programs that produce the buffer contents can also specify how to fontify it.
• Faces for Font Lock: Special faces specifically for Font Lock.
• Syntactic Font Lock: Fontification based on syntax tables.
• Setting Syntax Properties: Defining character syntax based on context using the Font Lock mechanism.
• Multiline Font Lock: How to coerce Font Lock into properly highlighting multiline constructs.

Multiline Font Lock Constructs

• Font Lock Multiline: Marking multiline chunks with a text property.
• Region to Fontify: Controlling which region gets refontified after a buffer change.

Documentation

• Documentation Basics: Good style for doc strings. Where to put them. How Emacs stores them.
• Accessing Documentation: How Lisp programs can access doc strings.
• Keys in Documentation: Substituting current key bindings.
• Describing Characters: Making printable descriptions of non-printing characters and key sequences.
• Help Functions: Subroutines used by Emacs help facilities.

Files

• Visiting Files: Reading files into Emacs buffers for editing.
• Saving Buffers: Writing changed buffers back into files.
• Reading from Files: Reading files into buffers without visiting.
• Writing to Files: Writing new files from parts of buffers.
• File Locks: Locking and unlocking files, to prevent simultaneous editing by two people.
• Information about Files: Testing existence, accessibility, size of files.
• Changing Files: Renaming files, changing protection, etc.
• File Names: Decomposing and expanding file names.
• Contents of Directories: Getting a list of the files in a directory.
• Create/Delete Dirs: Creating and Deleting Directories.
• Magic File Names: Defining "magic" special handling for certain file names.
• Format Conversion: Conversion to and from various file formats.

Visiting Files

• Visiting Functions: The usual interface functions for visiting.
• Subroutines of Visiting: Lower-level subroutines that they use.

Information about Files

• Testing Accessibility: Is a given file readable? Writable?
• Kinds of Files: Is it a directory? A symbolic link?
• Truenames: Eliminating symbolic links from a file name.
• File Attributes: How large is it? Any other names? Etc.
• Locating Files: How to find a file in standard places.

File Names

• File Name Components: The directory part of a file name, and the rest.
• Relative File Names: Some file names are relative to a current directory.
• Directory Names: A directory's name as a directory is different from its name as a file.
• File Name Expansion: Converting relative file names to absolute ones.
• Unique File Names: Generating names for temporary files.
• File Name Completion: Finding the completions for a given file name.
• Standard File Names: If your package uses a fixed file name, how to handle various operating systems simply.

File Format Conversion

• Format Conversion Overview: insert-file-contents and write-region.
• Format Conversion Round-Trip: Using format-alist.
• Format Conversion Piecemeal: Specifying non-paired conversion.

Backups and Auto-Saving

• Backup Files: How backup files are made; how their names are chosen.
• Auto-Saving: How auto-save files are made; how their names are chosen.
• Reverting: revert-buffer, and how to customize what it does.

Backup Files

• Making Backups: How Emacs makes backup files, and when.
• Rename or Copy: Two alternatives: renaming the old file or copying it.
• Numbered Backups: Keeping multiple backups for each source file.
• Backup Names: How backup file names are computed; customization.

Buffers

• Buffer Basics: What is a buffer?
• Current Buffer: Designating a buffer as current so that primitives will access its contents.
• Buffer Names: Accessing and changing buffer names.
• Buffer File Name: The buffer file name indicates which file is visited.
• Buffer Modification: A buffer is modified if it needs to be saved.
• Modification Time: Determining whether the visited file was changed ``behind Emacs's back''.
• Read Only Buffers: Modifying text is not allowed in a read-only buffer.
• The Buffer List: How to look at all the existing buffers.
• Creating Buffers: Functions that create buffers.
• Killing Buffers: Buffers exist until explicitly killed.
• Indirect Buffers: An indirect buffer shares text with some other buffer.
• Swapping Text: Swapping text between two buffers.
• Buffer Gap: The gap in the buffer.

Windows

• Basic Windows: Basic information on using windows.
• Splitting Windows: Splitting one window into two windows.
• Deleting Windows: Deleting a window gives its space to other windows.
• Selecting Windows: The selected window is the one that you edit in.
• Cyclic Window Ordering: Moving around the existing windows.
• Buffers and Windows: Each window displays the contents of a buffer.
• Displaying Buffers: Higher-level functions for displaying a buffer and choosing a window for it.
• Choosing Window: How to choose a window for displaying a buffer.
• Dedicated Windows: How to avoid displaying another buffer in a specific window.
• Window Point: Each window has its own location of point.
• Window Start and End: Buffer positions indicating which text is on-screen in a window.
• Textual Scrolling: Moving text up and down through the window.
• Vertical Scrolling: Moving the contents up and down on the window.
• Horizontal Scrolling: Moving the contents sideways on the window.
• Size of Window: Accessing the size of a window.
• Resizing Windows: Changing the size of a window.
• Coordinates and Windows: Converting coordinates to windows.
• Window Tree: The layout and sizes of all windows in a frame.
• Window Configurations: Saving and restoring the state of the screen.
• Window Parameters: Associating additional information with windows.
• Window Hooks: Hooks for scrolling, window size changes, redisplay going past a certain point, or window configuration changes.

Frames

• Creating Frames: Creating additional frames.
• Multiple Terminals: Displaying on several different devices.
• Frame Parameters: Controlling frame size, position, font, etc.
• Terminal Parameters: Parameters common for all frames on terminal.
• Frame Titles: Automatic updating of frame titles.
• Deleting Frames: Frames last until explicitly deleted.
• Finding All Frames: How to examine all existing frames.
• Frames and Windows: A frame contains windows; display of text always works through windows.
• Minibuffers and Frames: How a frame finds the minibuffer to use.
• Input Focus: Specifying the selected frame.
• Visibility of Frames: Frames may be visible or invisible, or icons.
• Raising and Lowering: Raising a frame makes it hide other windows; lowering it makes the others hide it.
• Frame Configurations: Saving the state of all frames.
• Mouse Tracking: Getting events that say when the mouse moves.
• Mouse Position: Asking where the mouse is, or moving it.
• Pop-Up Menus: Displaying a menu for the user to select from.
• Dialog Boxes: Displaying a box to ask yes or no.
• Pointer Shape: Specifying the shape of the mouse pointer.
• Window System Selections: Transferring text to and from other X clients.
• Drag and Drop: Internals of Drag-and-Drop implementation.
• Color Names: Getting the definitions of color names.
• Text Terminal Colors: Defining colors for text-only terminals.
• Resources: Getting resource values from the server.
• Display Feature Testing: Determining the features of a terminal.

Frame Parameters

• Parameter Access: How to change a frame's parameters.
• Initial Parameters: Specifying frame parameters when you make a frame.
• Window Frame Parameters: List of frame parameters for window systems.
• Size and Position: Changing the size and position of a frame.
• Geometry: Parsing geometry specifications.

Window Frame Parameters

• Basic Parameters: Parameters that are fundamental.
• Position Parameters: The position of the frame on the screen.
• Size Parameters: Frame's size.
• Layout Parameters: Size of parts of the frame, and enabling or disabling some parts.
• Buffer Parameters: Which buffers have been or should be shown.
• Management Parameters: Communicating with the window manager.
• Cursor Parameters: Controlling the cursor appearance.
• Font and Color Parameters: Fonts and colors for the frame text.

Positions

• Point: The special position where editing takes place.
• Motion: Changing point.
• Excursions: Temporary motion and buffer changes.
• Narrowing: Restricting editing to a portion of the buffer.

Motion

• Character Motion: Moving in terms of characters.
• Word Motion: Moving in terms of words.
• Buffer End Motion: Moving to the beginning or end of the buffer.
• Text Lines: Moving in terms of lines of text.
• Screen Lines: Moving in terms of lines as displayed.
• List Motion: Moving by parsing lists and sexps.
• Skipping Characters: Skipping characters belonging to a certain set.

Markers

• Overview of Markers: The components of a marker, and how it relocates.
• Predicates on Markers: Testing whether an object is a marker.
• Creating Markers: Making empty markers or markers at certain places.
• Information from Markers: Finding the marker's buffer or character position.
• Marker Insertion Types: Two ways a marker can relocate when you insert where it points.
• Moving Markers: Moving the marker to a new buffer or position.
• The Mark: How "the mark" is implemented with a marker.
• The Region: How to access "the region".

Text

• Near Point: Examining text in the vicinity of point.
• Buffer Contents: Examining text in a general fashion.
• Comparing Text: Comparing substrings of buffers.
• Insertion: Adding new text to a buffer.
• Commands for Insertion: User-level commands to insert text.
• Deletion: Removing text from a buffer.
• User-Level Deletion: User-level commands to delete text.
• The Kill Ring: Where removed text sometimes is saved for later use.
• Undo: Undoing changes to the text of a buffer.
• Maintaining Undo: How to enable and disable undo information. How to control how much information is kept.
• Filling: Functions for explicit filling.
• Margins: How to specify margins for filling commands.
• Adaptive Fill: Adaptive Fill mode chooses a fill prefix from context.
• Auto Filling: How auto-fill mode is implemented to break lines.
• Sorting: Functions for sorting parts of the buffer.
• Columns: Computing horizontal positions, and using them.
• Indentation: Functions to insert or adjust indentation.
• Case Changes: Case conversion of parts of the buffer.
• Text Properties: Assigning Lisp property lists to text characters.
• Substitution: Replacing a given character wherever it appears.
• Transposition: Swapping two portions of a buffer.
• Registers: How registers are implemented. Accessing the text or position stored in a register.
• Base 64: Conversion to or from base 64 encoding.
• MD5 Checksum: Compute the MD5 "message digest"/"checksum".
• Atomic Changes: Installing several buffer changes "atomically".
• Change Hooks: Supplying functions to be run when text is changed.

The Kill Ring

• Kill Ring Concepts: What text looks like in the kill ring.
• Kill Functions: Functions that kill text.
• Yanking: How yanking is done.
• Yank Commands: Commands that access the kill ring.
• Low-Level Kill Ring: Functions and variables for kill ring access.
• Internals of Kill Ring: Variables that hold kill ring data.

Indentation

• Primitive Indent: Functions used to count and insert indentation.
• Mode-Specific Indent: Customize indentation for different modes.
• Region Indent: Indent all the lines in a region.
• Relative Indent: Indent the current line based on previous lines.
• Indent Tabs: Adjustable, typewriter-like tab stops.
• Motion by Indent: Move to first non-blank character.

Text Properties

• Examining Properties: Looking at the properties of one character.
• Changing Properties: Setting the properties of a range of text.
• Property Search: Searching for where a property changes value.
• Special Properties: Particular properties with special meanings.
• Format Properties: Properties for representing formatting of text.
• Sticky Properties: How inserted text gets properties from neighboring text.
• Lazy Properties: Computing text properties in a lazy fashion only when text is examined.
• Clickable Text: Using text properties to make regions of text do something when you click on them.
• Fields: The field property defines fields within the buffer.
• Not Intervals: Why text properties do not use Lisp-visible text intervals.

Non-ASCII Characters

• Text Representations: How Emacs represents text.
• Converting Representations: Converting unibyte to multibyte and vice versa.
• Selecting a Representation: Treating a byte sequence as unibyte or multi.
• Character Codes: How unibyte and multibyte relate to codes of individual characters.
• Character Properties: Character attributes that define their behavior and handling.
• Character Sets: The space of possible character codes is divided into various character sets.
• Scanning Charsets: Which character sets are used in a buffer?
• Translation of Characters: Translation tables are used for conversion.
• Coding Systems: Coding systems are conversions for saving files.
• Input Methods: Input methods allow users to enter various non-ASCII characters without special keyboards.
• Locales: Interacting with the POSIX locale.

Coding Systems

• Coding System Basics: Basic concepts.
• Encoding and I/O: How file I/O functions handle coding systems.
• Lisp and Coding Systems: Functions to operate on coding system names.
• User-Chosen Coding Systems: Asking the user to choose a coding system.
• Default Coding Systems: Controlling the default choices.
• Specifying Coding Systems: Requesting a particular coding system for a single file operation.
• Explicit Encoding: Encoding or decoding text without doing I/O.
• Terminal I/O Encoding: Use of encoding for terminal I/O.
• MS-DOS File Types: How DOS "text" and "binary" files relate to coding systems.

Searching and Matching

• String Search: Search for an exact match.
• Searching and Case: Case-independent or case-significant searching.
• Regular Expressions: Describing classes of strings.
• Regexp Search: Searching for a match for a regexp.
• POSIX Regexps: Searching POSIX-style for the longest match.
• Match Data: Finding out which part of the text matched, after a string or regexp search.
• Search and Replace: Commands that loop, searching and replacing.
• Standard Regexps: Useful regexps for finding sentences, pages,...

Regular Expressions

• Syntax of Regexps: Rules for writing regular expressions.
• Regexp Example: Illustrates regular expression syntax.
• Regexp Functions: Functions for operating on regular expressions.

Syntax of Regular Expressions

• Regexp Special: Special characters in regular expressions.
• Char Classes: Character classes used in regular expressions.
• Regexp Backslash: Backslash-sequences in regular expressions.

The Match Data

• Replacing Match: Replacing a substring that was matched.
• Simple Match Data: Accessing single items of match data, such as where a particular subexpression started.
• Entire Match Data: Accessing the entire match data at once, as a list.
• Saving Match Data: Saving and restoring the match data.

Syntax Tables

• Syntax Basics: Basic concepts of syntax tables.
• Syntax Descriptors: How characters are classified.
• Syntax Table Functions: How to create, examine and alter syntax tables.
• Syntax Properties: Overriding syntax with text properties.
• Motion and Syntax: Moving over characters with certain syntaxes.
• Parsing Expressions: Parsing balanced expressions using the syntax table.
• Standard Syntax Tables: Syntax tables used by various major modes.
• Syntax Table Internals: How syntax table information is stored.
• Categories: Another way of classifying character syntax.

Syntax Descriptors

• Syntax Class Table: Table of syntax classes.
• Syntax Flags: Additional flags each character can have.

Parsing Expressions

• Motion via Parsing: Motion functions that work by parsing.
• Position Parse: Determining the syntactic state of a position.
• Parser State: How Emacs represents a syntactic state.
• Low-Level Parsing: Parsing across a specified region.
• Control Parsing: Parameters that affect parsing.

Abbrevs and Abbrev Expansion

• Abbrev Mode: Setting up Emacs for abbreviation.
• Abbrev Tables: Creating and working with abbrev tables.
• Defining Abbrevs: Specifying abbreviations and their expansions.
• Abbrev Files: Saving abbrevs in files.
• Abbrev Expansion: Controlling expansion; expansion subroutines.
• Standard Abbrev Tables: Abbrev tables used by various major modes.
• Abbrev Properties: How to read and set abbrev properties. Which properties have which effect.
• Abbrev Table Properties: How to read and set abbrev table properties. Which properties have which effect.

Processes

• Subprocess Creation: Functions that start subprocesses.
• Shell Arguments: Quoting an argument to pass it to a shell.
• Synchronous Processes: Details of using synchronous subprocesses.
• Asynchronous Processes: Starting up an asynchronous subprocess.
• Deleting Processes: Eliminating an asynchronous subprocess.
• Process Information: Accessing run-status and other attributes.
• Input to Processes: Sending input to an asynchronous subprocess.
• Signals to Processes: Stopping, continuing or interrupting an asynchronous subprocess.
• Output from Processes: Collecting output from an asynchronous subprocess.
• Sentinels: Sentinels run when process run-status changes.
• Query Before Exit: Whether to query if exiting will kill a process.
• System Processes: Accessing other processes running on your system.
• Transaction Queues: Transaction-based communication with subprocesses.
• Network: Opening network connections.
• Network Servers: Network servers let Emacs accept net connections.
• Datagrams: UDP network connections.
• Low-Level Network: Lower-level but more general function to create connections and servers.
• Misc Network: Additional relevant functions for network connections.
• Serial Ports: Communicating with serial ports.
• Byte Packing: Using bindat to pack and unpack binary data.

Receiving Output from Processes

• Process Buffers: If no filter, output is put in a buffer.
• Filter Functions: Filter functions accept output from the process.
• Decoding Output: Filters can get unibyte or multibyte strings.
• Accepting Output: How to wait until process output arrives.

Low-Level Network Access

• Network Processes: Using make-network-process.
• Network Options: Further control over network connections.
• Network Feature Testing: Determining which network features work on the machine you are using.

Packing and Unpacking Byte Arrays

• Bindat Spec: Describing data layout.
• Bindat Functions: Doing the unpacking and packing.
• Bindat Examples: Samples of what bindat.el can do for you!

Emacs Display

• Refresh Screen: Clearing the screen and redrawing everything on it.
• Forcing Redisplay: Forcing redisplay.
• Truncation: Folding or wrapping long text lines.
• The Echo Area: Displaying messages at the bottom of the screen.
• Warnings: Displaying warning messages for the user.
• Invisible Text: Hiding part of the buffer text.
• Selective Display: Hiding part of the buffer text (the old way).
• Temporary Displays: Displays that go away automatically.
• Overlays: Use overlays to highlight parts of the buffer.
• Width: How wide a character or string is on the screen.
• Line Height: Controlling the height of lines.
• Faces: A face defines a graphics style for text characters: font, colors, etc.
• Fringes: Controlling window fringes.
• Scroll Bars: Controlling vertical scroll bars.
• Display Property: Enabling special display features.
• Images: Displaying images in Emacs buffers.
• Buttons: Adding clickable buttons to Emacs buffers.
• Abstract Display: Emacs' Widget for Object Collections.
• Blinking: How Emacs shows the matching open parenthesis.
• Usual Display: The usual conventions for displaying nonprinting chars.
• Display Tables: How to specify other conventions.
• Beeping: Audible signal to the user.
• Window Systems: Which window system is being used.

The Echo Area

• Displaying Messages: Explicitly displaying text in the echo area.
• Progress: Informing user about progress of a long operation.
• Logging Messages: Echo area messages are logged for the user.
• Echo Area Customization: Controlling the echo area.

Reporting Warnings

• Warning Basics: Warnings concepts and functions to report them.
• Warning Variables: Variables programs bind to customize their warnings.
• Warning Options: Variables users set to control display of warnings.

Overlays

• Managing Overlays: Creating and moving overlays.
• Overlay Properties: How to read and set properties. What properties do to the screen display.
• Finding Overlays: Searching for overlays.

Faces

• Defining Faces: How to define a face with defface.
• Face Attributes: What is in a face?
• Attribute Functions: Functions to examine and set face attributes.
• Displaying Faces: How Emacs combines the faces specified for a character.
• Face Remapping: Remapping faces to alternative definitions.
• Face Functions: How to define and examine faces.
• Auto Faces: Hook for automatic face assignment.
• Font Selection: Finding the best available font for a face.
• Font Lookup: Looking up the names of available fonts and information about them.
• Fontsets: A fontset is a collection of fonts that handle a range of character sets.
• Low-Level Font: Lisp representation for character display fonts.

Fringes

• Fringe Size/Pos: Specifying where to put the window fringes.
• Fringe Indicators: Displaying indicator icons in the window fringes.
• Fringe Cursors: Displaying cursors in the right fringe.
• Fringe Bitmaps: Specifying bitmaps for fringe indicators.
• Customizing Bitmaps: Specifying your own bitmaps to use in the fringes.
• Overlay Arrow: Display of an arrow to indicate position.

The display Property

• Replacing Specs: Display specs that replace the text.
• Specified Space: Displaying one space with a specified width.
• Pixel Specification: Specifying space width or height in pixels.
• Other Display Specs: Displaying an image; adjusting the height, spacing, and other properties of text.
• Display Margins: Displaying text or images to the side of the main text.

Images

• Image Formats: Supported image formats.
• Image Descriptors: How to specify an image for use in :display.
• XBM Images: Special features for XBM format.
• XPM Images: Special features for XPM format.
• GIF Images: Special features for GIF format.
• TIFF Images: Special features for TIFF format.
• PostScript Images: Special features for PostScript format.
• Other Image Types: Various other formats are supported.
• Defining Images: Convenient ways to define an image for later use.
• Showing Images: Convenient ways to display an image once it is defined.
• Image Cache: Internal mechanisms of image display.

Buttons

• Button Properties: Button properties with special meanings.
• Button Types: Defining common properties for classes of buttons.
• Making Buttons: Adding buttons to Emacs buffers.
• Manipulating Buttons: Getting and setting properties of buttons.
• Button Buffer Commands: Buffer-wide commands and bindings for buttons.

Abstract Display

• Abstract Display Functions: Functions in the Ewoc package.
• Abstract Display Example: Example of using Ewoc.

Display Tables

• Display Table Format: What a display table consists of.
• Active Display Table: How Emacs selects a display table to use.
• Glyphs: How to define a glyph, and what glyphs mean.

Operating System Interface

• Starting Up: Customizing Emacs startup processing.
• Getting Out: How exiting works (permanent or temporary).
• System Environment: Distinguish the name and kind of system.
• User Identification: Finding the name and user id of the user.
• Time of Day: Getting the current time.
• Time Conversion: Converting a time from numeric form to calendrical data and vice versa.
• Time Parsing: Converting a time from numeric form to text and vice versa.
• Processor Run Time: Getting the run time used by Emacs.
• Time Calculations: Adding, subtracting, comparing times, etc.
• Timers: Setting a timer to call a function at a certain time.
• Idle Timers: Setting a timer to call a function when Emacs has been idle for a certain length of time.
• Terminal Input: Accessing and recording terminal input.
• Terminal Output: Controlling and recording terminal output.
• Sound Output: Playing sounds on the computer's speaker.
• X11 Keysyms: Operating on key symbols for X Windows.
• Batch Mode: Running Emacs without terminal interaction.
• Session Management: Saving and restoring state with X Session Management.

Starting Up Emacs

• Startup Summary: Sequence of actions Emacs performs at startup.
• Init File: Details on reading the init file.
• Terminal-Specific: How the terminal-specific Lisp file is read.
• Command-Line Arguments: How command-line arguments are processed, and how you can customize them.

Getting Out of Emacs

• Killing Emacs: Exiting Emacs irreversibly.
• Suspending Emacs: Exiting Emacs reversibly.

Terminal Input

• Input Modes: Options for how input is processed.
• Recording Input: Saving histories of recent or all input events.

Tips and Conventions

• Coding Conventions: Conventions for clean and robust programs.
• Key Binding Conventions: Which keys should be bound by which programs.
• Programming Tips: Making Emacs code fit smoothly in Emacs.
• Compilation Tips: Making compiled code run fast.
• Warning Tips: Turning off compiler warnings.
• Documentation Tips: Writing readable documentation strings.
• Comment Tips: Conventions for writing comments.
• Library Headers: Standard headers for library packages.

GNU Emacs Internals

• Building Emacs: How the dumped Emacs is made.
• Pure Storage: A kludge to make preloaded Lisp functions sharable.
• Garbage Collection: Reclaiming space for Lisp objects no longer used.
• Memory Usage: Info about total size of Lisp objects made so far.
• Writing Emacs Primitives: Writing C code for Emacs.
• Object Internals: Data formats of buffers, windows, processes.

Object Internals

• Buffer Internals: Components of a buffer structure.
• Window Internals: Components of a window structure.
• Process Internals: Components of a process structure.

1 介绍

GNU Emacs文本编辑器大部分由称为Emacs Lisp的编程语言写成，你可以用Emacs Lisp编写代码并将其作为扩展安装到Emacs上。然而，Emacs Lisp并不仅仅是一个“扩展性语言”，它是一个全功能的计算机编程语言，你可以象你用其他编程语言那样地使用它。

由于Emacs Lisp被设计成在编辑器内使用，它具有一些如扫描和分析文本以及处理文件、缓冲区、显示和子进程等独有的特性。Emacs Lisp和各种编辑功能紧密的结合在一起，因此，编辑命令可以做为函数在Lisp程序中被调用，而编辑器的定制参数就是普通的Lisp变量。

本文档将致力于对Emacs Lisp进行全面性的描述，对于初学者而言，如想阅读一些介绍性的文档，请参考由Free Software Foundation出版，Bob Chassell所写的An Introduction to Emacs Lisp Programming 。本书假定读者对于使用Emacs进行编辑有一定的了解，如需这方面的知识，可参考The GNU Emacs Manual文档。

总体而言，本书前面的章节描述了Emacs Lisp和其他编程语言相对应的一些特性，后面的章节则重点介绍Emacs Lisp独有的特性以及和编辑相关的特性。

本文档的版本为3.0，对应于Emacs版本23.3。

• 注意事项: 注意事项以及缺陷说明。
• Lisp历史: Emacs Lisp派生自MacLisp。
• 惯例: 本参考文档的内容格式说明。
• 版本信息: Emacs版本信息。
• 致谢: 作者、编辑者以及赞助者信息。

1.1 注意事项

本文档几易其稿，但还不能说是完整无错。目前还有一些主题未被覆盖到，要么是因为它们相对次要（如大部分的独立mode），要么是因为还未来得及撰写， 正是因为我们暂时不能处理完它们，所以我们将这些内容刻意省略掉了。

本文档覆盖到的地方，基本上是正确无误的，因它对于它讲述的内容，从特定示例和描述性的文字到章节顺序等，欢迎读者指正。如果某些内容让你觉得疑惑， 或者需要通过查阅代码或者做实验来确定本文章未覆盖的内容，这说明本文档可能需要被修正，请知会我们。

在您使用本文档时，一时你发现错误，请您将其发送给我们；如果您发现一个简单且真实的例子来说明一个或一组函数，请尽量能将其写下来发给我们，请您 引用一下章节名、函数名或变量名，并说明一下您阅读文本的版本号。

请使用M-x report-emacs-bug提供宝贵建议和纠错。

1.2 Lisp历史

Lisp（LISt Processing luanguage）于20世纪50年代在麻省理工学院（MIT）为研究人工智能而被首次开发出来。Lisp语言的强大能力使得它也 能应用于其他目的，如编写编辑命令。 此后的许多年里，许多不同风格的Lisp实现被开发出来，它们大多数受到了20世纪60年代在MIT的MAC项目编写的Maclisp的启发。最终这些实现者坐到 了一起，制定了Lisp系统的标准，称作Common Lisp。同时，MIT的Gerry Sussman和Guy Steele开发了一个简单但强大的Lisp方言（译注：这里沿用目前 翻译中通用的称法，Lisp的各种变种通常被称为方言），称作Scheme。

GNU Emacs Lisp受到的大部分的启发来自于Maclisp，小部分来自于Common Lisp。如果你熟悉Common Lisp，你将注意到很多相似点，然而，由于为 了降低GNU Emacs的内存需求，很多Common Lisp的特性被忽略或者简化；有时这些简化变动很大使得Common Lisp用户感到迷惑；我们将不时的指出GNU Emacs Lisp与Common Lisp不同，如果你不熟悉Common Lisp，不要紧，本文档是自包含的。 一部分Common Lisp的仿真可以通过cl库来得到，请查看相应内容see Overview。

Emacs Lisp并未受到任何来自Scheme的影响，但GNU项目也有一个称作Guile的Scheme实现，为了扩展性，我们新的GNU软件将都使用Guile开发(译注： 从这点也说明了Lisp的强大，可以用来实现各种软件，比如有名的Reddit网站早期就使用Common Lisp写成)。

1.3 惯例

如下章节解释了本文档中的一些记法惯例，你可以跳过本章节，后面可以跳回查阅。

• 一些名词: 介绍本文档所用名词。
• nil和t: 符号nil和t如何使用。
• 求值记法: 求值记法格式说明。
• 打印记法: 示例代码输出结果格式说明。
• 错误信息: 错误信息格式说明。
• 缓冲区文本记法: 缓冲区文本格式说明。
• 描述信息格式: 函数、变量等描述信息格式说明。

1.3.1 一些名词

纵贯本文档，”Lisp读取器“和"Lisp打印器"指那些Lisp用来将那些用文字表示的Lisp对象转为实际的Lisp对象以及实现相反功能的例程，细节请参考See 打印表示, 。你，正在阅读本文档的人，被认为是"程序员"并用"你"来着重强调。"用户"则指使用Lisp程序的人，包括你编写的Lisp程序。

Lisp示例代码被格式化成如(list 1 2 3)这样的形式，那些被描述的元语法变量（译注：所谓元语法变量，简单来说，就是为了说明语言本身所提出 一些变量，如foo、bar这些，关于详细的解释，请参考这个链接：元语法变量。 , 或者函数的参数，将被格式化成如first-number这样的形式。

1.3.2 nil和t

在Lisp中，nil符号有三重意义：

1) 名为‘nil’的符号 2) 逻辑真值false 3) 空表（具有零个成员的表）

当它被用作变量时，nil的值总是nil。

对于Lisp读取器而言，‘()’和‘nil’是相等的，它们代表同样的Lisp对象，即符号nil，只所以采用不同的方式书写，主要是从读者的 角度考虑，在Lisp读取器读取了‘()’或‘nil’后，没有办法知道用户到底是用哪种形式编写的。

在本文档中，我们在需要强调空表时，将用()表示，而当我们强调逻辑真值false时，将用false表示，这也是一种好的Lisp编程惯例。

     (cons 'foo ())                ; 强调空表
     (setq foo-flag nil)           ; 强调真值false

在需要真值的上下文中，所有非nil的值都被当做true 对待；然而推荐用t来表示真值中的true 。当你需要选择一个表示真值 true的值时，如果没有其他的考虑，建议使用t，符号t永远具有值t。

在Emacs Lisp中，nil和t是求值是自身的特殊符号，因此你可以不必引用（译注：引用是Emacs Lisp中的一个重要概念，对应于quote函数， 后面会讲到）它们而把它们当做常量使用，尝试改变它们的值将得到setting-constance错误，详情请参考See Constant Variables,。

1.3.3 求值记法

你可以进行求值操作的Lisp表达式称作型（译注：英文对应为form，因Lisp中最为常用的结果叫List，翻译过来都叫表，不易区分，因此这里翻译作型） ，对型进行求值总是得到一个结果，该结果是一个Lisp对象，在本文档的示例中，该过程用‘⇒’表示：

     (car '(1 2))
          ⇒ 1

对上述过程你可以称为“car '(1 2))求值结果为1”。

当一个型是宏调用时，它将被展开为一个新的型，用于Lisp进行求值，我们用‘==>’表示展开结果，除外，我们也有可能将型最终的求值结果也表示出来：

     (third '(a b c))
          ==> (car (cdr (cdr '(a b c))))
          ⇒ c

有时为了表示两个型产生相同的结果，我们用‘==’表示两个型严格相等：

     (make-sparse-keymap) == (list 'keymap)

1.3.4 打印记法

本文档的许多示例都会打印文本信息；如果你在Lisp的交互缓冲区（如‘*scratch*’）中执行示例代码时，打印出的文本信息将会被插入到该缓冲区中， 而如果你通过其他方式执行示例代码（如对eval-region函数进行求值），打印的文本信息将在回显区显示。

本文档的示例中使用‘-|’表示打印出的文本信息，而不考虑它们输出到什么地方，而型的求值结果（下面的示例中是bar）将和‘⇒’ 跟在文本信息的下面一行：

     (progn (prin1 'foo) (princ "\n") (prin1 'bar))
          -| foo
          -| bar
          ⇒ bar

1.3.5 错误信息

一些示例将给出错误信息，这通常是在回显区显示一个错误信息，我们用‘error-->’开头的一行来显示错误信息，注意‘error-->’并不会显示在回显区中：

     (+ 23 'x)
     error--> Wrong type argument: number-or-marker-p, x

1.3.6 缓冲区文本记法

一些示例通过对文本的“前”、“后”版本的显示，演示如何对缓冲区的文本内容进行修改，这些示例将用两行中划线来标识缓冲区的文本内容， 除外，‘-!-’显示点的位置（当然，点的符号，并不是缓冲区文本的一部分，它标识了两个字符之间即点所处的位置）。

     ---------- Buffer: foo ----------
     This is the -!-contents of foo.
     ---------- Buffer: foo ----------
     
     (insert "changed ")
          ⇒ nil
     ---------- Buffer: foo ----------
     This is the changed -!-contents of foo.
     ---------- Buffer: foo ----------

1.3.7 描述信息格式

函数、变量、宏、命令、用户选项以及特殊型在本文档中用统一的形式进行描述。描述的第一行将是名称及其参数，如果可能的话，在第一行还会 显示其所属类别—函数、变量或其他任意形式。

函数、变量或者其他任何其他类别，将出现在行的开头。 描述信息紧跟在后面，有时候还会伴有示例。

• 函数描述示例: 虚构函数foo描述说明。
• 变量描述示例: 虚构变量electric-future-map描述说明。

1.3.7.1 函数描述示例

在函数描述中，首先是函数的名称，跟着是参数名称列表，这些参数名称也将用在函数体中，代表参数的值。 在参数列表中，关键字&optional表示后面的参数（称为可选参数）可以被忽略，被忽略的参数的值默认为nil，注意在调用函数时不要加 &optional；而关键字&rest（后面必须只跟一个参数，也即说明&rest必须出现在最后一个参数的前面）表示在调用时，从&rest 所在位置开始，可以传递任意参数，这些任意参数将被合成在一个表中，作为单个参数（称为剩余参数）传递给函数，同样，在调用函数时不要加&rest。

下面是一个虚构的函数foo的描述：

任何参数，如果其命名包含类型名（如integer、integer1或buffer），通常表示该参数需要是该类型，而复数的命名（如buffers） 通常表示一个拥有该类型对象的表。参数指名的object可以是任意类型（详细的类型列表，请查阅See Lisp数据类型.)，其他方式命名的参数（如new-file） 将在函数描述中进行特别讨论。在某些章节中，一些函数参数的共性描述，将在前面首先描述。

对于可选和剩余参数更为完整的描述，请参考See Lambda Expressions.。

命令、宏和特殊型的描述也采用上述形式，但字`Function'将被替换为对应的`Command'、`Macro'或`Special Form'，命令是可以被交互式调用的 简单函数，宏处理参数的方式和函数不同（参数不进行求值），但仍用和函数相同的形式进行描述。

特殊型的描述用一种更为复杂的记法来指定可选和重复参数，这是因为它可以将参数列表用更为复杂的方式进行分解。‘[optional-arg]’ 说明那个optional-arg是可选的，而‘repeated-args...’代表零或多个参数，括号用来将若干个参数组成有层次的表结构。下面是一个 示例：

1.3.7.2 变量描述示例

变量指可以持有值的名字。尽管接近所有的变量都可以由用户设置，部分变量专门用来由用户改变，这些变量称为用户选项，常规变量和 用户选项使用和函数相同的描述，除了没有参数列表外。

下面是一个虚构的electric-future-map变量的描述： variable.

用户选项的描述与上面的变量描述相同，只不过`Variable'将被替换为`User Option'。

1.4 版本信息

下面这些函数用于确定当前使用Emacs版本。

下面这两个变量从Emacs 19.23版本开始存在：

1.5 致谢

此节不再翻译，值得一提的是，在翻译本文档时，这里有一个中国人的名字，即Chong YiDong，当前这位仁兄正在美国研究物理，是目前的EMACS的总维护 者，对于牛人，我们除了敬仰外，还需要学习如何达到同样的高度：）。

本文档由如下作者写成：Robert Krawitz, Bil Lewis, Dan LaLiberte, Richard M. Stallman and Chris Welty, the volunteers of the GNU manual group, in an effort extending over several years. Robert J. Chassell helped to review and edit the manual, with the support of the Defense Advanced Research Projects Agency, ARPA Order 6082, arranged by Warren A. Hunt, Jr. of Computational Logic, Inc. Additional sections were written by Miles Bader, Lars Brinkhoff, Chong Yidong, Kenichi Handa, Lute Kamstra, Juri Linkov, Glenn Morris, Thien-Thi Nguyen, Dan Nicolaescu, Martin Rudalics, Kim F. Storm, Luc Teirlinck, and Eli Zaretskii.

如下人员提供了纠错信息：Drew Adams, Juanma Barranquero, Karl Berry, Jim Blandy, Bard Bloom, Stephane Boucher, David Boyes, Alan Carroll, Richard Davis, Lawrence R. Dodd, Peter Doornbosch, David A. Duff, Chris Eich, Beverly Erlebacher, David Eckelkamp, Ralf Fassel, Eirik Fuller, Stephen Gildea, Bob Glickstein, Eric Hanchrow, Jesper Harder, George Hartzell, Nathan Hess, Masayuki Ida, Dan Jacobson, Jak Kirman, Bob Knighten, Frederick M. Korz, Joe Lammens, Glenn M. Lewis, K. Richard Magill, Brian Marick, Roland McGrath, Stefan Monnier, Skip Montanaro, John Gardiner Myers, Thomas A. Peterson, Francesco Potorti, Friedrich Pukelsheim, Arnold D. Robbins, Raul Rockwell, Jason Rumney, Per Starbäck, Shinichirou Sugou, Kimmo Suominen, Edward Tharp, Bill Trost, Rickard Westman, Jean White, Eduard Wiebe, Matthew Wilding, Carl Witty, Dale Worley, Rusty Wright, and David D. Zuhn.

2 Lisp数据类型

Lisp对象是由Lisp程序所使用或操作的一块数据，从Emacs Lisp的角度来讲，一个类型或数据类型是一些对象的集合。

每一个对象至少属于一个类型。具有相同类型的对象具有相似的数据结构，并经常在相同的上下文环境中被使用。类型可以重叠，对象可以属于两到多个类型， 因此，我们可以问对象是否属于一个特定类型，但不能说对象的类型是什么。

Emacs集成了一些基础的对象类型。这些类型是其他类型构造的基础，它们称为基础类型。每一个对象只能属于一个基础类型。这些类型包括整型、浮点型、 cons、符号、字符串、容器、哈希表、子函数、字节码函数以及一些特殊类型，如缓冲区等与编辑相关的类型。(See 编辑类型.)

每一个基础类型都有一相应的Lisp函数，用来检查对象是否属于该类型。

Lisp不同于其他语言，它的对象是类型自说明的，也即每个对象的原子类型隐含在对象自身里。例如，如果一个对象是容器类型，则不能将其做为数字进行处理，Lisp知道它属于容器，而非数字。

在大多数的语言里，程序员必须声明每个变量的类型，编译器知道其类型，该类型并不由数据表示。这种声明方式在Emacs Lisp中并不存在。一个Lisp变量可以具有任何类型的数据，并且记住你存储在 它里边的任何值及其类型等所有信息。（实际上，少数Emacs Lisp变量仅能存储特定类型的值，请参考See Variables with Restricted Values.）。

本章节将描述GNU Emacs Lisp中每个标准类型的作用、打印表示以及读取语法，如何使用这些类型，将在后面的章节进行详述。

• 打印表示: Lisp对象如何以文本形式进行表示。
• 注释: 注释及其格式惯例。
• 编程类型: 所有Lisp系统中出现的类型。
• 编辑类型: Emacs特定的类型。
• 循环对象: 循环结构的读取语法。
• 类型判定: 关于类型的验证函数。
• 相等判定: 任何两个对象的相等验证函数。

2.1 打印表示和读取语法

对象的打印表示是指Lisp打印器（prin1函数的功能）对该对象的输出格式。每个数据类型都具有唯一的输出表示。对象的读取语法则指对该对象的Lisp读取器所接受的输入格式， 读取语法并不需要唯一，许多对象具有一个或多个读取语法（请参考See Read and Print.）。

大多情况下，一个对象的打印表示也是其读取语法。然而，某些类型并没有读取语法，这是因为在Lisp程序中并没有必要以常量的形式输入这些类型的对象。这些对象以哈希记法的形式打印，即由 ‘#<’、描述字符串（通常是对象名跟上类型名）以及一个终结的‘>’组成。例如：

     (current-buffer)
          ⇒ #<buffer objects.texi>

哈希记法不能被读取，所以当Lisp读取器遇到一个‘#<’时将会产生一个invalid-read-syntax错误。 在其他语言里，表达式就是文本；没有其他形式。在Lisp中，一个表达式首先是一个Lisp对象，其次则是该对象的读取语法。通常不必做此区分，则你需要在脑中记住这一点，否则你将不时会觉得非常 迷惑。

当你以交互形式对表达式求值时，Lisp解释器将首先读取该表达式的文本表示，产生一个Lisp对象，然后对该对象进行求值（see Evaluation）。然而，求值和读取是两项活动，读取返回该文本 所表示的对象，该对象在后面可能会被求值，也可能不会。请参考See Input Functions.，了解read即读取对象的基本函数的描述。

2.2 注释

注释是那些在程序中为了供人阅读程序的文本，对于程序本身没有任何影响。在Lisp中，不在一个字符串或字符常量中出现的一个分号（‘;’），表明注释开始直至行尾。Lisp读取器丢弃注释， 它们在Lisp系统中并不成为表示程序的Lisp对象的一部分。

‘#@count’构造器，跳过后继count个字符，适用于程序产生的包含二进制数据的注释。Emacs Lisp字节编译器在其输出文件中使用该构造器（参考see Byte Compilation）， 但它并非为源文件所设计。

想要了解格式注释的惯例，请参考See Comment Tips.一节。

2.3 编程类型

在Emacs Lisp中，有两类常见的类型，即用于Lisp编程的类型以及与编辑有关的类型，前者在许多Lisp实现中以各种形式存在，而后者则是Emacs Lisp特有的。

• 整数类型: 不包含分数部分的数字。
• 浮点类型: 包含分数部分的数字，具有更大的值域。
• 字符类型: 字母、数字以及控制字符的表示。
• 符号类型: 多用途的对象，用于引用函数、变量或者属性表，具有唯一的标识。
• 序列类型: 表和数组都被归为序列。
• Cons Cell类型: Cons cells,和表(由Cons cell组成)。
• 数组类型: 数据包括字符串和容器。
• 字符串类型: 有效的字符数组。
• 容器类型: 一维数组。
• 字符表类型: 由字符索引的稀松一维数组。
• 布尔容器类型: 由t或nil组成的一维数组。
• 哈希表类型: 超快的查找表。
• 函数类型: 一块被调用的可执行代码。
• 宏类型: 用于将表达式展开成另外一个更基本但不美观的表达式的方法。
• 原始函数类型: 由C语言写成的函数，在Lisp程序中调用。
• 字节码类型: Lisp写成的函数，编译后的对象。
• 自动加载类型: 自动加载较少使用的函数。

2.3.1 整数类型

Emacs Lisp中的整数范围为−536870912至536870911（30位，例如： -2**29 to 2**29 - 1) 在大数机器上（某些机器将提供更宽的范围），需要注意Emacs Lisp算术运算函数并不检查溢出，因此(1+ 536870911)就是−536870912。

整数的读取语法由一系列十进制的数字加上开始的可选符号再加上可选的结束的数点组成。Lisp解释器产生的打印表示，并不会加上前置的‘+’或后置的‘.’。

     -1               ; 整数-1。
     1                ; 整数1。
     1.               ; 同样是整数1。
     +1               ; 同样是整数1。
     1073741825       ; 在30位实现时，同样是整数1,译注：此处错误，与下段说明也矛盾，不是1,而是浮点数1073741825.0

有个特例则是，如果由一串数字表示的整数太大或者大小，不能成为有效的整数型对象时，Lisp读取器将以浮点数据读取（请参考see 浮点类型）。比如在大多数 机器上，536870912都将被读取成浮点数536870912.0。

更详细的信息，请参考See Numbers.一节。

2.3.2 浮点类型

浮点数是科学计数法的计算机记法，你可以将浮点数理解为分数加上10的幂值。有效位精度以及指数范围与机器相关;Emacs使用C语言的double类型来存储浮 点数值，其内部采用2的幂值而非10的幂值。

浮点数的打印表示可以是一个数点（至少有一个数字跟在其后）、一个指数、或者两个都包含。如‘1500.0’、‘15e2’、‘1.5e3’以及‘.15e4’ 是表示具有值1500的浮点数的五种表示方法，它们是相等的。

更详细的信息，请参考See Numbers.一节。

2.3.3 字符类型

Emacs Lisp中的字符仅是一个整数而已，换句话说，字符由其字符编码表示。例如 ，字符A由整数65表示。

程序中时常会使用到单个字符，但更常见到的则是字符串，即由字符组成的序列。请参考See 字符串类型.。

字符串和缓冲区中的字符当前被限制在0到4194303，也即20位（请参考see Character Codes）。编码0到127即ASCII编码；其余的称为 非ASCII字符。代表键盘输入的字符，具有更宽的范围，它们用来编码Control、Meta、Shift等修饰键。

为了方便处理消息，Emacs Lisp有一些特殊函数，用于对一些字符产生可读的文本描述。请参考See Describing Characters.。

• 基本字符语法: 一般字符的语法。
• 一般转义语法: 如何使用编码表示字符。
• Ctl-字符语法: Ctl-字符语法。
• Meta-字符语法: Meta-字符语法。
• 其他字符修饰位: hyper-字符、 super-字符、 以及alt-字符语法。

2.3.3.1 基本字符语法

由于字符实际上就是整数值，字符的打印语法就是一个十进制数值。这也是字符的读取语法之一，但在Lisp程序中用这种方式并不是清晰的编程方式。你应当总是 使用Emacs Lisp提供的字符的特殊读取语法，这些语法用以问号开头。

字母型字符的通常读取语法是在字母前边前上问号，因此，‘?A’表示字符A，‘?B’表示字符B，‘?a’则表示字符a。

示例：

     ?Q ⇒ 81     ?q ⇒ 113

你可以使用相同的语法来表示标点字符，但通常在该字符前再加上一个‘\’更好一些，以便使Emacs编辑Lisp代码的命令不致于迷惑。例如‘?\(’用于表示 左括号。如果字符是‘\’，你则必须再在前面添加一个‘\’来表示它：‘?\\’。

你可以用‘?\a’、‘?\b’、‘?\t’、‘?\n’、‘?\v’、‘?\f’、‘?\s’、‘?\r’、‘?\d’以及‘?\e’分别表示 Control-g、退格、制表、换行、垂直制表、换页、空格、回车、删除以及退出字符。（折线以及跟在其后的‘?\s’则具有不同的含义，它表示对此组合后面的字符进行“super” 修饰。）因此：

     ?\a ⇒ 7                 ; control-g, C-g
     ?\b ⇒ 8                 ; 退格, <BS>, C-h
     ?\t ⇒ 9                 ; 制表, <TAB>, C-i
     ?\n ⇒ 10                ; 换行, C-j
     ?\v ⇒ 11                ; 垂直制表, C-k
     ?\f ⇒ 12                ; 换页, C-l
     ?\r ⇒ 13                ; 回车, <RET>, C-m
     ?\e ⇒ 27                ; 退出, <ESC>, C-[
     ?\s ⇒ 32                ; 空格, <SPC>
     ?\\ ⇒ 92                ; 反斜钱, \
     ?\d ⇒ 127               ; 删除, <DEL>

由反斜线开始的序列也被称为转义序列，由于反斜线扮演了“转义字符”的角色；此术语与<ESC>无关。‘\s’则用在字符常量， 在字符串常量中，则用来表示空格。

在不具有特殊转义的字符前插入反斜线是允许的，并且是无害的，因此，‘?\+’与‘?+’等价。通常对于大多数字符而言，没有必要增加反斜线，但是， 你需要在‘()\|;'`"#.,’前增加反斜线，以避免迷惑编辑Lisp代码的Emacs命令。你也可以在空白字符如空格、制表、换行以及换页符前插入反斜线，但是，最 好使用易读的转义序列，如‘\t’或‘\s’来替代实际的如制表、空格等空白字符。（如果你在空格前输入了反斜线，你应当在其后再增加一个空格，以使其 与后面的文本区分开。译注：这句话较为疑惑，实际上在字符串中插入反斜线+空格会当被忽略，如"\ bbb"与"bbb"的值相等）。

2.3.3.2 一般转义语法

除针对特殊控制字符的特殊转义序列外，Emacs提供了针对于非ASCII文本字符的几类转义语法。

你可以通过字符的Unicode编码来指定它。?\unnnn代表映射到Unicode码点‘U+nnnn’的字符（按照惯例，Unicode码点以十六 进制数给出）。对于码点高于U+nnnn的字行，需要用稍微不同的语法，即\U00nnnnnn，它代表码点为‘U+nnnnnn’的 字符。Unicode标准只定义了最高为‘U+10ffff’的码点，所以如果你定义大于该码点的字符，Emacs将产生一个错误。

之所以采用这种奇怪和不便的语法，主要是是为了和其他语言兼容。与其他语言不同，Emacs只在字符串常量和字符串中支持此语法。

字符最常见的读取语法用10进制或16进制字符码表示。采用10进制时，采用问号跟上一个反斜线加上10进制字符码（用3位10进制数字）的形式，因此‘?\101’表示字符 A，‘?\001’表示字符C-a，而?\002表示C-b。尽管这种语法可表示任意ASCII字符，但除非用精确的10进制数值表示 比ASCII表示重要时才用这种语法。

     ?\012 ⇒ 10         ?\n ⇒ 10         ?\C-j ⇒ 10
     ?\101 ⇒ 65         ?A ⇒ 65

采用16进制时，采用问号跟上一个反斜线加上‘x’再加上对应的16进制字符码的形式。你可以使用任意数量的16进制数，所以在这种方式下你可以表示任意字符。因此 ‘?\x41’表示A，‘?\x1’表示C-a，而?\x8e0表示Latin-1字符 ‘a’加上重音符。

2.3.3.3 Ctl-字符语法

控制字符可以采用另外一种读取语法，它由问号跟上一个反斜线加上脱字符再加上相应的非控制字字符（大小写皆可）。例如，‘?\^I’有‘?\^i’均是控制字符 C-i的有效读取语法，其相应的整数值是9。

除了‘^’外，你还可以使用‘C-’来替代，因此‘?\C-i’和‘?\^I’以及‘?\^i’等效。

     ?\^I ⇒ 9     ?\C-I ⇒ 9

在字符串和缓冲区中，只有在那些ASCII中存在的控制字符才允许出现。但考虑到键盘输入的需求，你可以用‘C-’将任意字符转换为控制字符，这些非 ASCII控制字符的编码除对应的非控制字符外，还包括被设置上的第 2**26 位，普通的终闻风而动无法产生非ASCII字符，但在X或者其他窗口系统下，你可以很容易的构造它们。

由于历史原因，Emacs将<DEL>字符与?控制字符（译注：即‘?\C-?’）视为等价字符。（译注：感兴趣的朋友不妨试下，在Emacs中,Ctl-?与DEL键的作用是相同的：））

     ?\^? ⇒ 127     ?\C-? ⇒ 127

因此，当前不可能表示在X窗口系统下的有效按键Control-?，由于大量的Lisp文件用这样的方式引用<DEL>，因此很难改变这个问题。

在表示文件或字符串的控制字符时，我们推荐用‘^’那样的语法，而在处理键盘输入的控制字符时，我们倾向于使用‘C-’语法，无论采用哪种语法，都不会对程序的意义产生任 何影响，但却可以指导用户更好的理解该程序。

2.3.3.4 Meta-字符语法

meta字符指那些用<META>修饰的字符，用于表示这种字符的整数，其第 2**27 位被设置成上。我们使用高位来表示此修饰符以及其他修饰符，以便得到更宽的基本字符码。

在字符串里，当一个ASCII字符第 2**7 位被设置上时，表示它是一个meta字符，因此，可以被包含在字符串的meta字符具有128~255的范围，即普通ASCII字符的meta版本。 （请参考See Strings of Events.一节，以便了解字符串处理<META>的细节。）

meta字符的读取语法是‘\M-’。例如，‘?\M-A’代表M-A，你也可以用‘\M-’加上字符对应的十进制码，或者加上 ‘\C-’以及其他任意字符的读取语法。因此，你可以把M-A写做‘?\M-A’或者写做‘?\M-\101’，相似地，你可以把C-M-b 写做‘?\M-\C-b’或者写作‘?\C-\M-b’或者‘?\M-\002’。

2.3.3.5 其他字符修饰位

图形化字符的大小写由其字符码表示，如ASCII通过‘a’和‘A’区分大小写，但ASCII却没有办法区分控制字符 的大小写。Emacs使用第 2**25 位来表示在键入控制字符时是否使用了shift键。仅在你使用X终端或者其他特殊终端时才可能做此区分，普通终端并不会上报这种区分。shift位的语法 为‘\S-’，因此‘?\C-\S-o’或‘?\C-\S-O’代表shifted-control-o字符。

X窗口系统定义了字符中可以出现的其他三个修饰位：hyper、super以及alt，对应的语法为 ‘\H-’、‘\s-’以及‘\A-’。（这些前缀需要区分大小写。）因此，‘?\H-\M-\A-x’表示Alt-Hyper-Meta-x。（注意 不跟‘-’的‘\s’代表空格字符。） 从数值上来说，alt相应的位为2**22，super相应的位为2**23，而hyper相应的位为2**24。

2.3.4 符号类型

GNU Emacs Lisp中的符号是指具有名字的一个对象，符号名做为符号的打印表示。在常规Lisp应用中，借助于一个obarray（请参考see Creating Symbols） ，符号的名称是唯一的，也即没有两个同名的符号。

符号可以做为变量、函数名或者维护一个属性表，或者仅仅是为了和所有其他Lisp对象进行区分，以便可以可靠地识别出其在数据结构中的存在。在一个指定的上下文环境中， 通常符号只具有以上的一种用途， 但你可以独立地以任意以上方式使用该符号。

名字以冒号（‘:’）开始的符号称为关键字符号。这些符号将自动扮演常量的角色，并且通常只用于将未知符号与有限的替代符号进行比较。

符号名可以包含任意字符。大多数符号名由字母、数字以及标点符号‘-+=*/’组成。这些名字不需要特殊标记（译注：这里应当指用反斜线括起来），只要符号名看起来 不像数字，那么就足够使用了。（如果符号名看起来是数字，那就在它前面添加一个‘\’，强制使它被解释成符号）。字符‘_~!@$%^&:<>{}?’很少在符号名中被使用， 它们也不需要被特殊标记。所有此外其他可能在符号名中出现的字符，都需要用反斜线进行转义。与字符串中的反斜线应用相比，符号名中的反斜线只是简单的将反斜线后的单个字符括起 来，例如，在字符串中，‘\t’代表一个制表符，而符号名中的‘\t’，则仅仅是将字母‘t’括起来（译注：根据本段前面的描述，字母t是不需要转义的，因此符号名 中的\t与t实际上是相同的，可以通过symbol-name '\tb以及symbol-name 'tb对比看看。）。为了在符号名中引入制表符，你需要用反斜线加上一个真实的 制表符来表示，但却很少需要这样做。

Common Lisp注记: 在Common Lisp中，小写字符总是被转成大写，除非它们被精确的转义。在Emacs Lisp中，大小写字母是不同的。

以下是符号名的几个例子。注意第五个例子中的‘+’被转义，以避免该符号被解释成数字，这种方式在第四个例子中并不需要，这里因为该符号名并不能被当做数字解释。

     foo                 ; 名为‘foo’的符号。
     FOO                 ; 名为‘FOO’的符号, 与‘foo’不同。
     1+                  ; 名为‘1+’的符号。
                         ;   (不是‘+1’, 它是一个数字)。
     \+1                 ; 名为‘+1’的符号。
                         ;   (并不是一个非常可读的名字)。
     \(*\ 1\ 2\)         ; 名为‘(* 1 2)的符号’ (糟糕的名字)。
     
     
     +-*/_~!@$%^&=:<>{}  ; 名为‘+-*/_~!@$%^&=:<>{}的符号’。
                         ;   这些符号不需要转义。

通常Lisp读取器扣留所有符号（译注：英文名为intern，目前暂找不出更好的名字，在Emacs中，intern就是将符号插入obarray中，而避免intern 就是相当于让符号游离在obarray之外。）。你可以在符号名前添加‘#:’来避免扣留发生。

2.3.5 序列类型

序列是一个代表有序元素集的对象。在Emacs Lisp中，有两类序列，即表和数组。因此，表对象或者数组对象都可以认为是序列。

数组可以继续被细分为字符串、容器、字符表以及布尔容器。容器可以存储任何类型的元素，但字符串必须存储字符，而布尔容器的元素则只能是t 或nil。字符表除了它被任意有效字符索引的特性外，很象容器。字符串里的字符们可以像缓冲区里的字符一样，具有文本属性。（请参考see Text Properties）， 但容器即使其元素是字符，也并不支持文本属性。

表、字符串以及其他的数组类型是不同的，但它们却具有一些相似性。例如，都有一个长度l，并且其元素可以以0到l减一的的数值去索引。某些被称为 序列函数，可以接受各种序列。例如，函数elt可以通过指定一个索引获取序列中的一个元素。（请参考See Sequences Arrays Vectors.）

因为序列总是在读取时被创建，因此通常不可能将同一个序列读取两次，如果你对序列的读取语法读取了两次，你将得到两个具有相同内容的序列（译注：这句话强调的应当是 将产生两个相同内容但不同的序列对象），但有一个不同，空表()总是代表相同的对象，即nil。

2.3.6 Cons Cell和表类型

cons cell是一个具有两个槽的对象，分别称为car槽和cdr槽。每个槽都可以持有或指向任意Lisp对象。我们也用 “这个cons cell的car”来指代该对象car槽持有的任意对象，对于cdr槽持有的对象相似，可做相似称呼。

C程序员注意：在Lisp中，我们并不区分“持有”一个值和“引用”该值，因为在Lisp中，指针是隐式的。

表是一系列的cons cell，依次通过cdr链接在一起，每个cons cell的cdr槽或者引用下一个cons cell，或者 引用空表。对于那些操作表的函数，空表实际上是符号nil。（请参考See Lists.）因为大部分cons cell都作为表的 一部分，因此短语表结构被用来指代任何由cons cell组成的结构（译注：这里隐含着半句话，即“以便用来和表做区分”）。

由于cons cell们对于表如此重要，我们也有这样一个说法，即“不是cons cell的对象”，这些对象被称为原子。

表的读取语法和打印表示是相等的，并且包含一个左括号，任意数量的元素以及一个右括号。以下是表的例子：

     (A 2 "A")            ; 具有三个元素的表。
     ()                   ; 没有元素的表（空表）。
     nil                  ; 没有元素的表（空表）。
     ("A ()")             ; 具有一个元素的表，元素是："A ()"。
     (A ())               ; 具有两个元系的空表，元素是：A和空表。
     (A nil)              ; 同上。
     ((A B C))            ; 具有一个元素的表，表的元素是
                          ;   一个具有三个元素的表。

在读取时，括号内的每个对象都变成表的一个元素。也就是说，cons cell由各个元素组成。car槽持有一个元素，其cdr引用 表中的下一个cons cell，该cons cell持有表的下一个元素。表中最后个cons cell的cdr被设置为nil。

car和cdr从Lisp的历史演变而来。原始的Lisp实现运行在一个IBM 704计算机上，该计算机被分为两部分，分别叫作“地址”部分和 “剩余”部分；car是用于取得寄存器地址部分对应内容的指令，而cdr则是用于取得寄存器剩余部分对应内容的指令。相比之下，“cons cells”用于命名 创建它的函数cons，即如其名所识，construction of cells。（译注：这句不翻译，否则不易理解cons cells的意义）

• 盒子图解: 对表进行图示。
• 点对记法: cons cells的常见语法。
• 关联表类型: 一种特殊构造的表。

2.3.6.1 将表画成盒子图表

可以将cons cells画成盒子对，象多米诺一样的形式对表进行图解。(Lisp读取器不能读取这种描绘方式，不象文本记法，可以被人和计算机读取，盒式描绘方式不能被 计算机读取：）)此图表示了一个具有三元素的表(rose violet buttercup)（）：

         --- ---      --- ---      --- ---
        |   |   |--> |   |   |--> |   |   |--> nil
         --- ---      --- ---      --- ---
          |            |            |
          |            |            |
           --> rose     --> violet   --> buttercup

在此图解中，每个盒子代表一个可以持有或者引用任意Lisp对象的槽。每对盒子对代表一个cons cell，每个箭头代表对一个Lisp对象的引用，该对象可以是一个原子， 也可以是另一个cons cell。

在这个例子中，第一个盒子，持有着第一个cons cell的car部分，引用rose（一个符号）。第二个盒子,持有第一个cons cell的cdr，引用下 一个cons cell。第二个cons cell的car是violet，它的cdr是第三个cons cell。第三个即最后一个cons cell的cdr是nil。

下面是该表的另一个图解，(rose violet buttercup)，用另外一个方式进行描绘。

      ---------------       ----------------       -------------------
     | car   | cdr   |     | car    | cdr   |     | car       | cdr   |
     | rose  |   o-------->| violet |   o-------->| buttercup |  nil  |
     |       |       |     |        |       |     |           |       |
      ---------------       ----------------       -------------------

没有元素的表称为空表；它等同于符号nil。换句话说，nil既是一个符号，又是一个表。

下面是表(A ())，或者等价的(A nil)，由盒子和箭头描绘：

         --- ---      --- ---
        |   |   |--> |   |   |--> nil
         --- ---      --- ---
          |            |
          |            |
           --> A        --> nil

下面是一个更为复杂的刻画，显示了一个三元素表((pine needles) oak maple)，第一个元素是一个具有两个元素的表：

         --- ---      --- ---      --- ---
        |   |   |--> |   |   |--> |   |   |--> nil
         --- ---      --- ---      --- ---
          |            |            |
          |            |            |
          |             --> oak      --> maple
          |
          |     --- ---      --- ---
           --> |   |   |--> |   |   |--> nil
                --- ---      --- ---
                 |            |
                 |            |
                  --> pine     --> needles

上述表用第二种盒子记法如下：

      --------------       --------------       --------------
     | car   | cdr  |     | car   | cdr  |     | car   | cdr  |
     |   o   |   o------->| oak   |   o------->| maple |  nil |
     |   |   |      |     |       |      |     |       |      |
      -- | ---------       --------------       --------------
         |
         |
         |        --------------       ----------------
         |       | car   | cdr  |     | car     | cdr  |
          ------>| pine  |   o------->| needles |  nil |
                 |       |      |     |         |      |
                  --------------       ----------------

2.3.6.2 点对记法

点对记法是用来显式表示car和cdr的常见语法。使用这种语法时，(a . b)表示car是对象a而cdr 是对象b的cons cell。由于cdr不一定需要是表，因此点对记法比表语法更为普遍。然而，在表语法可用时，如果使用点对记法，则显得较为笨拙。 在点对记法中，‘(1 2 3)’写作‘(1 . (2 . (3 . nil)))’。对于由nil终结的表，两种语法都可以使用，但表语法更为方便。当打印一 个表时，点对记法仅在cons cell的cdr不是一个表时使用。

下面是用盒子演示点对记法的一个例子。此例子显示点对(rose . violet)：

         --- ---
        |   |   |--> violet
         --- ---
          |
          |
           --> rose

借助于非nil终结的cdr，你可以组合点对记法和表记法来方便表示一个cons cell链。你在表的最后一个元素后写下一个点，并跟跟上最后一个 cons cell的cdr。例如，(rose violet . buttercup)和(code . (violet . buttercup))相等，这个对象看起来是这样的：

         --- ---      --- ---
        |   |   |--> |   |   |--> buttercup
         --- ---      --- ---
          |            |
          |            |
           --> rose     --> violet

语法(rose . violet . buttercup) 是无效的，这是因为它没有任何意义。如果非要说明其意义的话，可以说将buttercup放至 一个cons cell的cdr中，而该cons cell的cdr已经是violet了。（译注：这是由于(violet . buttercup)没有被括起来， 要好考体会一下上面对点对记法的描述。）

表(rose violet)和(rose . (violet)等价，它看起来是这个样子：

         --- ---      --- ---
        |   |   |--> |   |   |--> nil
         --- ---      --- ---
          |            |
          |            |
           --> rose     --> violet

相似地，三元素表(rose violet buttercup)与(rose . (violet . buttercup)等价。 它看起来是这个样子：

         --- ---      --- ---      --- ---
        |   |   |--> |   |   |--> |   |   |--> nil
         --- ---      --- ---      --- ---
          |            |            |
          |            |            |
           --> rose     --> violet   --> buttercup

2.3.6.3 关联表类型

关联表或alist是一种特殊构造的表，其元素是cons cells。在每个元素里，car被当作一个关键字，而cdr则被 当作关联值。（在某些情况下，关联值存储在cdr的car中。）关联表通常用作栈，因为在关联表的前面添加或删除关联很简单。

例如：

     (setq alist-of-colors
           '((rose . red) (lily . white) (buttercup . yellow)))

设置变量alist-of-colors为一个具有三元素的关联表。在第一个元素中，rose是关键字，而red是关联值。

要进步请了解关联表以及操作它的函数，请参考See Association Lists.一节。要了解另外一类用于处理大量具有关键字的的查找 表，请参考See Hash Tables.一节。

2.3.7 数组类型

数组由任意数量的槽组成，这此槽用于持有或引用其他Lisp对象，布局在连续的内存块中。访问数组的任意元素花费大约相同的时间。 相比下，访问表元素的时间则与元素在表中的位置成比例关系。（表靠后的元素访问起来要比表靠前的元素耗时长。）

Emacs定义了四类数组：字符串、容器、布尔容器以及字符表。

字符串是一个由字符构成的数组，而容器则是由任意Lisp对象构成的数组。布尔容器只可持有t或nil。这些数组长度可达 最大的整数值。而字符表则是由有效字符码索引的稀松数组，它可持有任意Lisp对象。

数组的第一个元素索引为0，第而个元素索引为1，依次类推。这称为自0开始的索引方式。例如，一个具有四元素的数组，其索引为 0、1、2、和3。数组最大的索引值为其长度减1。数组一旦被创建，其索引就固定了。

所有的Emacs Lisp数组都是一维的。（大部分其他语法都支持多维数组，但这并不必要，你可通过嵌套一维数组达到同样的效果）。每类 数组都具有其特有的读取语法，详见后续的章节。

数组类型是序列的子类，包含字符串类型、容器类型、布尔容器类型以及字符表类型。

2.3.8 字符串类型

字符串是由字符组成的数组。字符串在Emacs中有多种用途，正如在文本编辑器中的作用一样；例如，可以作为Lisp符号的名称， 作为给用消息，作为从缓冲区中读取的文本。在Lisp中的字符串是常量：对其求值得到相同的字符串。

关于操作字符串的函数，请参考See Strings and Characters.。

• 字符串语法: 如何指定字符串。
• 字符串中的非ASCII字符: 字符串中的国际化字符。
• 非打印字符: 字符串中不可打印的字符。
• 文本属性和字符串: 具有文本属性的字符。

2.3.8.1 字符串语法

字符串的读取语法以双引号开始，加上任意数量的字符，再加上另一个双引号结束，如"like this"。要在字符串中引用一个双引号， 请在双引号前加上反斜线；因此"\""是一个仅由反斜线组成的字符串。相似地，你可以通过在反斜线前增加反斜线，以便在字符串引用包 含反斜线，如："this \\ is a single embedded backslash"。

换行符对于字符串的读取语法而言并不特殊；你可以在两个反斜线之间插入换行符，它将成为字符串的一个字符，但被转义后的换行符，即 前面有一个‘\’的换行符，将不会成为字符串的一部分，即Lisp读取器将在读取字符串时忽略该换行符。相似地，一个转义后的空格‘\ ’ 也将被忽略。

     "It is useful to include newlines
     in documentation strings,
     but the newline is \
     ignored if escaped."
          ⇒ "It is useful to include newlines
     in documentation strings,
     but the newline is ignored if escaped."

2.3.8.2 字符串中的非ASCII字符

你可以在字符串常量中逐字地写下非ASCII国际化字符。在Emacs字符串（和缓冲区中），对于非ASCII字符， 有两种表示：单字节或多字符。如果字符串常量从多字节源中读取，如多字节缓冲区或多字节字符串，或一个可以以多字节方式 访问的文件，那么字符将以多字节字符地形式被读取，进而使得字符串成为多字节的。如果字符串常量从单字节源中读取，那么 字符将以单字节形式读取，进而使得字符串成为单字节的。

对于多字节非ASCII字符，你还可以用其字符编码表示它：使用一个十六进制转义，‘\xnnnnnnn’， 必要时可以用任意的数字。（多字节非ASCII字符的编码都大于256。）任意下一个字符如果其十六进制数字无效，将 使得停止读取字符串。如果下一个字符可以被解释成十六进制数字，写一个‘\ ’（反斜线加上空格）来终止这个十六进制 转义—例如，字符串中的‘\x8e0\ ’代表加上重音符的‘a’。字符串中的‘\ ’就像转义后的换行符 一样，它并不在字符串中产生任何字符，但它可以终止前面的十六进制转义。

对于单字节非ASCII字符，你可以用其字符编码表示它，字符编码必须介于128(八进制的0200)至255（八进制 的0377）。如果你在字符串中写的全部是这种字符，没有其他使得字符串强制变为多字节字符串的字符，则产生一个单字节字符串， 然而。在字符串中使用任何十六进制转义（即使是一个ASCII字符的十六进制转义），也将使字符串强制成为多字符 字符串。

通过‘\u’和‘\U’，你还可以在字符串以字符串的Unicode数值指定字符。（请参考see 字符类型）。

要了解更多关于单字节和多字节的文本表示，请参考See Text Representations.一节。

2.3.8.3 非打印字符

你可以在字符串中使用和字符文字中相同的反斜线转义序列（但不要使用开启字符常量的?标记）。例如，你可以像"\t, \C-a" 这样写下一个包含非打印字符制表符或C-a，并用逗号和空格分隔它们的字符串。（关于字符的读取语法，请参考See 字符类型.）

然而，并不是所有的反斜线转义序列在字符串中都有有效的。字符串中唯一允许的控制字符即那些ASCII控制字符。字符串不区分 ASCII控制字符的大小写。

恰当地说，字符串不能包含meta字符，但当一个字符串被用作按键序列时，有一个特殊惯例用来在字符串中代表ASCII字符的meta版本。 你可以用‘\M-’语法在字符串常量中表示meta字符。这将设置字符串中该字符的第 2**7 位。如果该字符用于define-key或lookup-key, 这个数值将被转换为相等的meta字符。（请参考See 字符类型.。）

字符串不能持有带有hyper、super或alt修饰的字符。

2.3.8.4 字符串中的文本属性

字符串除持有字符外，还可以持有其存储字符的属性。这使得那些在字符串和缓冲区间拷贝字符的程序可以不费力地拷贝文本属性。要了解对文本属性的 解释，请参考See Text Properties.一节。带有文本属性的字符串使用一个特殊的读取语法：

     #("characters" property-data...)

property-data包括0到多个的元素，被分为如下三组：

     beg end plist

元素beg和end是整数，它们一起指定了字符串的特定区域；plist是此区域的属性。例如：

     #("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))

代表一个字符串，其文本内容为‘foo bar’，在此字符串，前三个字符具有一个值为bold的face属性， 而后面的三个字符则具有一个值为italic的face属性。（第四个字会没有文本属性，因此它的属性表为nil）。 实际上并不需要指明nil作为属性表，这是因为未在任何区域内提及的字符默认没有任何属性。）

2.3.9 容器类型

容器是一个包含任意类型元素的一维数组。访问其元素花费的时间固定。（在表中，访问表元素的时间则与元素在表中的位置成比例关系。）

容器的打印表示包含一个左方括号，容器元素，以及一个右方括号。这也是其读取语法。像数字和字符串一样，元素在被当作常量进行求值。

     [1 "two" (three)]      ; 具有三个元素的容器。
          ⇒ [1 "two" (three)]

要了解操作容器的函数，请参考See Vectors.一节。

2.3.10 字符表类型

字符表是一个由字符码索引的包含任意类型元素的一维数组。它具有某些额外特性，使其在许多涉及为字符码赋予信息的任务中变得更为有用 —例如，字符表可以具有一个具有默认值的父类，并有少量的槽用于特殊目的。字符表也可以对整个字符集设置单个值。

字符表的打印语法和容器相似，除了在开头有一个额外的‘#^’之外。

要了解操作字符表的特殊函数，请参考See Char-Tables.。

字符表的应用包括：

• 字符表 (see Case Tables).
• 字符归类表 (see Categories).
• 显示表 (see Display Tables).
• 语法表 (see Syntax Tables).

2.3.11 布尔容器类型

布尔容器类型是一个元素只能是t或nil的一维数组。

布尔容器的打印语法与字符串相似，除了它由一个‘#&’加上一个长度开始外。后面跟的字符串常量实际上以位图形式指明了布尔容器的 内容—字符串中的每个“字符”包含8个位，用来指尔布尔容器的下8个元素（1代表t，0代表nil）。字符的最低有效位对 应于布尔容器的最小索引。

     (make-bool-vector 3 t)
          ⇒ #&3"^G"
     (make-bool-vector 3 nil)
          ⇒ #&3"^@"

这个结果是有意义的，因为‘C-g’的二进制码为111，而‘C-@’是一个二进制码为0的字符。

如果布尔容器的长度不是8的倍数，其打印表示将显示多余的元素，但这些元素实际上没有意义。例如，在下一个例子中，那两个布尔容器 相等，但只有前三个位有用：

     (equal #&3"\377" #&3"\007")
          ⇒ t

2.3.12 哈希表类型

哈希表是一类非常快的查找表，与将关键字映射到值的关联表有几分相似，但更快。其打印表示指明了其属性和内容，像这样：

     (make-hash-table)
          ⇒ #s(hash-table size 65 test eql rehash-size 1.5
                                  rehash-threshold 0.8 data ())

要了解关于哈希表的更多信息，请参考See Hash Tables.。

2.3.13 函数类型

Lisp函数是可执行的做戏，就像其他语言中的函数一样。在Lisp中，不同于其他语言，函数也是Lisp对象。Lisp中未编译 的函数是一个lambda表达式：即第一个元素的符号lambda的表（请参考see Lambda Expressions.）。

在大多数编程语言中，不可能存在一个没有名字的函数。在Lisp中，函数没有固有的名字。一个lambda表达式可以被当 作函数被调用，即使它没有名字。为了强调这个概念，我们也将这个函数称作匿名函数（请参考see Anonymous Functions）。 Lisp中具有名字的函数只是函数单元具有一个有效函数的符号而已（请参考see Defining Functions）。

大多数情况下，在Lisp程序中，函数以在Lisp表达式中写下其名字地方式被调用。然而，你可以在运行时构造或获取一个函数对 象，然而使用原子函数funccall有apply调用它。（请参考See Calling Functions.）

2.3.14 宏类型

Lisp宏是一个用户定义的构造器，用来扩充Lisp语言。它由一个像函数的对象表示，但具有不同的参数传递语义。Lisp宏 具有表的形式，该表的第一个元素是符号macro，此表的cdr是一个Lisp函数对象，包括lambda符号。

Lisp宏对象通常使用内置函数defmacro定义，只要Emacs注意到，任何由macro开始的表都是一个宏。关于 如何写作宏，请参考See Macros.。

警告: Lisp宏和键盘宏（参考see Keyboard Macros）是完全不同的事物。当我们未对“宏”这个语做限定时， 我们指一个Lisp宏，而不是键盘宏。

2.3.15 原始函数类型

原始函数是一个可被Lisp调用但用C写成的函数。原始函数也被称做子程序（译注：英文subr）或内置函数。（词“subr”派生自 “subroutine”）大多数原始函数在被执行时，将对所有参数进行求值。不对所有参数求值的原始函数称作特殊型（请参考see Special Forms）。

对于调用者而言，函数是否是是原始的并不重要。然而，如果你要尝试用Lisp编写的函数重定义一个原始函数时，你就需要注意了。原因在于原始函数也许 会从C代码中直接调用，对于从Lisp中发起的对于重定义的函数的调用将使用新定义，而从C代码中的调用仍使用原来的函数。

术语function指所有Emacs的函数，无论是用Lisp还是C写成。关于Lisp写成函数的信息，请参考See 函数类型.一节。

原子函数没有读取语法，用哈希记法加上子程序的名字打印。

     (symbol-function 'car)          ; 访问符号的函数单元
          ⇒ #<subr car>
     (subrp (symbol-function 'car))  ; 是原始函数吗？
          ⇒ t                       ; 是。

2.3.16 字节码类型

字节码编译器产生字节码函数对象。从内部来看，一节字节码函数对象更像一个容器；然则 当它以被调用函数的形式出现时， 求值器对这种数据类型进行特殊处理。关于字节码编译器的信息，请参考See Byte Compilation.一节。

字节码函数的打印表示和读取语法像容器一样，但在开始的‘[’之前，有一个附加的‘#’。

2.3.17 自动加载类型

自动加载对象是一个第一个元素为符号autoload的表。它做为符号的函数定义存在，为真实的定义占位。自动加载对 象表示真实的定义可以在文件或Lisp代码中找到，并在需要时被加载。它包含文件的名字，以及有关真实定义的某些其他信息。

当文件被加载后，该符号将具有一个一个非自动加载对象的函数。新定义就像一直存在一样被调用。从用户的角度看，函数调用如期望 的那样工作，并使用在加载文件的函数定义。

一个自动加载对象通常使用函数autoload创建，并将该对象存储在符号的函数单元。关于更多细节，请参考See Autoload.。

2.4 编辑类型

在前面章节中谈到的类型用于一般的编程需要，它们的大部分在其他Lisp方言中也很常见。Emacs Lisp提供了一些与编辑相关的附加 数据类型，

• 缓冲区类型: 编辑的基本对象。
• 标记类型: 缓冲区的一个位置。
• 窗口类型: 缓冲区在窗口中显示。
• 框类型: 窗口分割框。
• 终端类型: 显示框的终端设备。
• 窗口配置类型: 记录框的分割方式。
• 框配置类型: 记录所有框的状态。
• 进程类型: Emacs的子进程，进行在所属OS上。
• 流类型: 接收或发送字符。
• 按键映射类型: 按键发生时，哪个函数被调用。
• 覆盖类型: 覆盖如何表示。
• 字体类型: 用于显示文本的字体。

2.4.1 缓冲区类型

缓冲区是一个持有可编辑文本的对象（请参考（see Buffers）。大多数缓冲区持有硬盘文件的内容，以便它们可以被编辑， 但某些缓冲区用于其他目的。大多数缓冲区也意味着用户可见，因此某些时候显示在一个窗口里（see Windows.）。 但缓冲并非必需显示 在任何窗口里。每个缓冲区具有一个分配的位置，称作点（请参考see Positions）；大多数编辑命令在操作当前缓冲区点周围的 内容。无论何时，只有一个缓冲区是当前缓冲区。

缓冲区的内容和字符串很像，但缓冲区的操作并不像Emacs Lisp中操作字符串一样，它可用的操作是不同的。例如，你可以高效地向既有 的缓冲中插入文本，替换缓冲区内容，而“插入”文本到字符串则需要连结子字符串，而结果是一个全新的字符串对象。

许多标准Emacs函数操作或测试当前缓冲区的字符；本文档专门有整个章节来描述这些函数（请参考see Text）。

每个缓冲区都关联了一些其他数据结构：

• 一个局部语法表(see Syntax Tables)；
• 一个局部按键射(see Keymaps)；和
• 一个缓冲区局部范围的变量绑定表(see Buffer-Local Variables)。
• 覆盖(see Overlays).
• 缓冲区文本的文本属性(see Text Properties)。

局部按键映射和变量表包含用于独立改写全局绑定或值的表项。它们用于定制程序在不同缓冲中的形为，而不影响该程序。

缓冲区可以是间接的，意味着它可以与另一个缓冲共享文本，但用不同的方式呈现。（请参考See Indirect Buffers.）

缓冲区没有读取语法。它们用哈希记法打印，显示缓冲区名。

     (current-buffer)
          ⇒ #<buffer objects.texi>

2.4.2 标记类型

标记表示特定缓冲区的一个位置。标记具有两个组成部分：一个面向缓冲区，一个面向位置。缓冲区文本发生改变时，将自动重定位 位置值，以便保证标记总是指向缓冲区中相同的两个字符之间。

标记没有读取语法。它们以哈希记法打印，显示当前缓冲区位置以及缓冲区名。

     (point-marker)
          ⇒ #<marker at 10779 in objects.texi>

要了解如何测试、创建、拷贝以及移动标记，请参考See Markers.一节。

2.4.3 窗口类型

窗口描述Emacs用来显示缓冲区使用的终端屏幕的一部分。每个窗口都有一个关联的缓冲区，该缓冲区的内容出现在窗口 上。相反地，一个给定的缓冲区，可以显示在一个窗口里、不在窗口中显示或显示在几个窗口中。

尽管许多窗口可以同时存在，但在任何时候，只有一个窗口被指定为选中窗口。这是在Emacs准备接受命令时，光标通常显示 的窗口。选中窗口通常显示当前缓冲区，但这并不一定。（译注：在编程时，可以使用Lisp操作缓冲区，而该缓冲区不一定是当前缓冲区）。

窗口在屏幕上被分组到框里；每个窗口属于一个且只能属于一个框。请参考See 框类型.。

窗口没有读取语法。它们以哈希记法打印，显示窗口编号以及它显示的缓冲区名。窗口号用于唯一区分窗口，因为指定窗口中的缓冲区 可能频繁变化。

     (selected-window)
          ⇒ #<window 1 on objects.texi>

关于操作窗口函数的描述，请参考See Windows.一节。

2.4.4 框类型

框是一个包含一至多个Emacs窗口的屏幕区域；我们也用术语“框”来指Emacs用来指屏幕区域的Lisp对象。

框没有读取语法。它们以哈希记法打印，显示框的标题，以及其在Emacs核心中的地址（用来唯一识别框）。

     (selected-frame)
          ⇒ #<frame emacs@psilocin.gnu.org 0xdac80>

关于操作框函数的描述，请参考See Frames.一节。

2.4.5 终端类型

终端是一个能够显示一到多个Emacs框的设备（请参考see 框类型）。

终端没有读取语法。它们以哈希记法表示，显示终端的序号以及其TTY设备文件名。

     (get-device-terminal nil)
          ⇒ #<terminal 1 on /dev/tty>

2.4.6 窗口配置类型

窗口配置一个框中窗口的有关存储位置、大小以及内容的信息，所以你可以后续重新创建相同的窗口布置。

窗口配置没有读取语法；它们的打印语法是‘#<window-configuration>’的形式。关于对与窗口配置相关的 一些函数的描述，请参考See Window Configurations.一节。

2.4.7 框配置类型

框配置存储所有框中窗口的有关存储位置、大小以及内容的信息。它不是一个原始类型—它是一个表，表的car是 frame-configuration并且cdr是一个关联表。关联表的每个元素描述一个框，该框作为该元素的car。

关于对与框配置有关的一些函数的描述，请参考See Frame Configurations.一节。

2.4.8 进程类型

进程通常意味着一个正在运行的程序。Emacs本身就运行在一个这样的进程中。然而，在Emacs Lisp中，一个进程是一 个被分配了一个Emacs进程创建的子进程的Lisp对象。程序如shells、GDB、ftp以及编译器，运行在Emacs的子进程中，扩展了Emacs 的能力。

所有的Emacs子进程都接受来自Emacs的文本输入，并返回文本输出给Emacs供进一步的吕作。Emacs也可产生信号给这些子进程。

进程对象没有读取语法。它们以哈希记法打印，显示进程的名字。

     (process-list)
          ⇒ (#<process shell>)

关于用来创建、删除、返回信息、发送输入或信号以及接收进程输出的函数的描述，请参考See Processes.一节。

2.4.9 流类型

流是一个可以用作字符源或字符接收端的对象—或为输入提供字符或接受字符做为输出。许多不同的类型可以被这样 使用：标记、缓冲区、字符串以及函数。通常，输入流（字符源）从键盘、缓冲区或文件，而发送流（字符接收端）向如*Help*缓冲区 或回显区发送字符。

对象nil，除了它其他的含义外，也可做为流使用。它代表变量standard-input或standard-output。同样的， 对象t也可做为流，代表使用minibuffer（请参考see Minibuffers）的输入，或回显区的输出（请参考see The Echo Area）。

流不具有特殊的打印表示或读取语法，它将以其原始类型打印。

关于与流有关的函数，包括解析或打印函数，请参考See Read and Print.一节。

2.4.10 按键映射类型

按键映射将用户的按键映射到命令上。这个映射控制用户命令输入如何执行。一个键盘映射实际上是一个表，该表的car是符号 keymap。

关于创建按键映射、处理前缀按键、本地以及全局按键映射以及改变按键绑定的信息，请参考See Keymaps.一节。

2.4.11 覆盖类型

覆盖指定应用于缓冲区的一部分的属性。每个覆盖应用于缓冲区的一个指定范围，包含一个属性表（表的元素是替换的属性名以及属性值） 。覆盖属性用于将缓冲区的部分内容用不同的显示风格进行呈现。覆盖没有读取语法，用哈希记法进行打印，显示缓冲区名字以及位置范围。

关于如何创建覆盖，请参考See Overlays.一节。

2.4.12 字体类型

字体指定如何在图形终端上显示文本。实际上有三种不同的字体类型—字体对象、字体规格以及字体实体—每 个都具有不同的属性。它们均没有读取语法；它们的打印语法分别是‘#<font-object>’、‘#<font-spec>’以及‘#<font-entity>’ 的形式。关于这些Lisp对象的描述，请参考See Low-Level Font.一节。

2.5 循环对象的读取语法

为展示复杂Lisp对象中的共享或循环结构，你可以使用‘#n=’和‘#n#’这样的读取构造器。

在对象前使用#n=来标记它供后续引用，后续你可以使用#n#另一个地方来引用该对象。这里的n是一个整数。 例如，下面构造了一个表，在此表中，第一个元素将在第三个元素处再次出现。

     (#1=(a) b #1#)

这与一般的如下语法不同

     ((a) b (a))

此语法产生一个表，表的第一个元素与第三个元素看起来相像，但不是同一个Lisp对象。下面显示其差异：

     (prog1 nil
       (setq x '(#1=(a) b #1#)))
     (eq (nth 0 x) (nth 2 x))
          ⇒ t
     (setq x '((a) b (a)))
     (eq (nth 0 x) (nth 2 x))
          ⇒ nil

你可以使用相同的语法来创建一个循环结构，它自身将作为一个“元素”出现在其自身里。下面是一个例子：

     #1=(a #1#)

这将构造一个表，该表的第二个元素是表自身。下面显示它确实能够工作：

     (prog1 nil
       (setq x '#1=(a #1#)))
     
     (eq x (cadr x))
          ⇒ t

Lisp打印器可以产生这种语法，用来记录Lisp对象中的循环或共享结构，如果你绑定变量print-circle到一个非nil值。 （请参考See Output Variables.一节）

2.6 类型判定

Emacs Lisp解释器它自身并不在函数调用时对传递给函数的实参进行类型检查。它不能这样做是由于Lisp函数的参数并没有类型声明，像 其他编程语言那样。因此检查每个参数是否属于函数可以使用的类型的工作，需要由单个函数自己完成。

所有的内置函数都检查它们的实际参数，在合适的时候，如果一个参数类型参数，将产生wrong-type-argument错误。例如， 下面是你向+传递一个它不能处理的参数时将会发生的现象：

     (+ 2 'a)
          error--> Wrong type argument: number-or-marker-p, a

如果你想让你的程序对不同的类型进行不同的处理，你必须进行显式地类型检查。检查对象的类型最常见的方式就是调用一个称为类型判定 的函数。Emacs对每个类型都提供了一个类型判定，以及一些针对组合类型的判定。

类型判定函数接受一个参数；如果参数属于合适的类型，它将返回t，否则返回nil。为遵循Lisp针对类型判定函数的一般惯例， 大多数类型判定名以‘p’结尾。(译注：p是英文predicate的第一个字母。)

下面是使用listp判定来检查表以及symbolp来检查符号的一个例子。

     (defun add-on (x)
       (cond ((symbolp x)
              ;; 如果X是一个符号，将其放到表里
              (setq list (cons x list)))
             ((listp x)
              ;; 如果X是一个表，将其元素插入到表里
              (setq list (append x list)))
             (t
              ;; 我们只处理符号和表
              (error "Invalid argument %s in add-on" x))))

下面是一个以字母排序的预定义的类型判定表，指向后续的信息。

atom

See atom.

arrayp

See arrayp.

bool-vector-p

See bool-vector-p.

bufferp

See bufferp.

byte-code-function-p

See byte-code-function-p.

case-table-p

See case-table-p.

char-or-string-p

See char-or-string-p.

char-table-p

See char-table-p.

commandp

See commandp.

consp

See consp.

display-table-p

See display-table-p.

floatp

See floatp.

fontp

See Low-Level Font.

frame-configuration-p

See frame-configuration-p.

frame-live-p

See frame-live-p.

framep

See framep.

functionp

See functionp.

hash-table-p

See hash-table-p.

integer-or-marker-p

See integer-or-marker-p.

integerp

See integerp.

keymapp

See keymapp.

keywordp

See Constant Variables.

listp

See listp.

markerp

See markerp.

wholenump

See wholenump.

nlistp

See nlistp.

numberp

See numberp.

number-or-marker-p

See number-or-marker-p.

overlayp

See overlayp.

processp

See processp.

sequencep

See sequencep.

stringp

See stringp.

subrp

See subrp.

symbolp

See symbolp.

syntax-table-p

See syntax-table-p.

user-variable-p

See user-variable-p.

vectorp

See vectorp.

window-configuration-p

See window-configuration-p.

window-live-p

See window-live-p.

windowp

See windowp.

booleanp

See booleanp.

string-or-null-p

See string-or-null-p.

检查对象的类型最为普遍的方式就是调用type-of函数。回想一下每个元素都属于一个且仅一个原始类型；type-of告诉 你哪一个原始类型。但type-of并不知道关于非原始类型的任何信息。在大多数情况下，使用类型判定比type-of更为方便。

2.7 相等判定

下面我们描述用于测试两个对象相等性的函数。 其他函数测试特定类型对象的内容相等性，如字符串。对于这些判定，请参考后续描述 相应数据类型的章节。

相等测试是用递归实现的；如，给定两个cons cellx和y，(equal x y) 仅在下面的两个表达式返回t时返回t：

     (equal (car x) (car y))
     (equal (cdr x) (cdr y))

由于这种递归方式，循环表因此可能导致无穷循环（导致一个错误）。

3 Numbers

GNU Emacs supports two numeric data types: integers and floating point numbers. Integers are whole numbers such as −3, 0, 7, 13, and 511. Their values are exact. Floating point numbers are numbers with fractional parts, such as −4.5, 0.0, or 2.71828. They can also be expressed in exponential notation: 1.5e2 equals 150; in this example, ‘e2’ stands for ten to the second power, and that is multiplied by 1.5. Floating point values are not exact; they have a fixed, limited amount of precision.

• Integer Basics: Representation and range of integers.
• Float Basics: Representation and range of floating point.
• Predicates on Numbers: Testing for numbers.
• Comparison of Numbers: Equality and inequality predicates.
• Numeric Conversions: Converting float to integer and vice versa.
• Arithmetic Operations: How to add, subtract, multiply and divide.
• Rounding Operations: Explicitly rounding floating point numbers.
• Bitwise Operations: Logical and, or, not, shifting.
• Math Functions: Trig, exponential and logarithmic functions.
• Random Numbers: Obtaining random integers, predictable or not.

3.1 Integer Basics

The range of values for an integer depends on the machine. The minimum range is −536870912 to 536870911 (30 bits; i.e., -2**29 to 2**29 - 1), but some machines may provide a wider range. Many examples in this chapter assume an integer has 30 bits. The Lisp reader reads an integer as a sequence of digits with optional initial sign and optional final period.

      1               ; The integer 1.
      1.              ; The integer 1.
     +1               ; Also the integer 1.
     -1               ; The integer −1.
      1073741825      ; Also the integer 1, due to overflow.
      0               ; The integer 0.
     -0               ; The integer 0.

The syntax for integers in bases other than 10 uses ‘#’ followed by a letter that specifies the radix: ‘b’ for binary, ‘o’ for octal, ‘x’ for hex, or ‘radixr’ to specify radix radix. Case is not significant for the letter that specifies the radix. Thus, ‘#binteger’ reads integer in binary, and ‘#radixrinteger’ reads integer in radix radix. Allowed values of radix run from 2 to 36. For example:

     #b101100 ⇒ 44
     #o54 ⇒ 44
     #x2c ⇒ 44
     #24r1k ⇒ 44

To understand how various functions work on integers, especially the bitwise operators (see Bitwise Operations), it is often helpful to view the numbers in their binary form.

In 30-bit binary, the decimal integer 5 looks like this:

     00 0000  0000 0000  0000 0000  0000 0101

(We have inserted spaces between groups of 4 bits, and two spaces between groups of 8 bits, to make the binary integer easier to read.)

The integer −1 looks like this:

     11 1111  1111 1111  1111 1111  1111 1111

−1 is represented as 30 ones. (This is called two's complement notation.)

The negative integer, −5, is creating by subtracting 4 from −1. In binary, the decimal integer 4 is 100. Consequently, −5 looks like this:

     11 1111  1111 1111  1111 1111  1111 1011

In this implementation, the largest 30-bit binary integer value is 536,870,911 in decimal. In binary, it looks like this:

     01 1111  1111 1111  1111 1111  1111 1111

Since the arithmetic functions do not check whether integers go outside their range, when you add 1 to 536,870,911, the value is the negative integer −536,870,912:

     (+ 1 536870911)
          ⇒ -536870912
          ⇒ 10 0000  0000 0000  0000 0000  0000 0000

Many of the functions described in this chapter accept markers for arguments in place of numbers. (See Markers.) Since the actual arguments to such functions may be either numbers or markers, we often give these arguments the name number-or-marker. When the argument value is a marker, its position value is used and its buffer is ignored.

See max-char, for the maximum value of a valid character codepoint.

3.2 Floating Point Basics

Floating point numbers are useful for representing numbers that are not integral. The precise range of floating point numbers is machine-specific; it is the same as the range of the C data type double on the machine you are using.

The read-syntax for floating point numbers requires either a decimal point (with at least one digit following), an exponent, or both. For example, ‘1500.0’, ‘15e2’, ‘15.0e2’, ‘1.5e3’, and ‘.15e4’ are five ways of writing a floating point number whose value is 1500. They are all equivalent. You can also use a minus sign to write negative floating point numbers, as in ‘-1.0’.

Most modern computers support the IEEE floating point standard, which provides for positive infinity and negative infinity as floating point values. It also provides for a class of values called NaN or “not-a-number”; numerical functions return such values in cases where there is no correct answer. For example, (/ 0.0 0.0) returns a NaN. For practical purposes, there's no significant difference between different NaN values in Emacs Lisp, and there's no rule for precisely which NaN value should be used in a particular case, so Emacs Lisp doesn't try to distinguish them (but it does report the sign, if you print it). Here are the read syntaxes for these special floating point values:

positive infinity

‘1.0e+INF’

negative infinity

‘-1.0e+INF’

Not-a-number

‘0.0e+NaN’ or ‘-0.0e+NaN’.

To test whether a floating point value is a NaN, compare it with itself using =. That returns nil for a NaN, and t for any other floating point value.

The value -0.0 is distinguishable from ordinary zero in IEEE floating point, but Emacs Lisp equal and = consider them equal values.

You can use logb to extract the binary exponent of a floating point number (or estimate the logarithm of an integer):

3.3 Type Predicates for Numbers

The functions in this section test for numbers, or for a specific type of number. The functions integerp and floatp can take any type of Lisp object as argument (they would not be of much use otherwise), but the zerop predicate requires a number as its argument. See also integer-or-marker-p and number-or-marker-p, in Predicates on Markers.

3.4 Comparison of Numbers

To test numbers for numerical equality, you should normally use =, not eq. There can be many distinct floating point number objects with the same numeric value. If you use eq to compare them, then you test whether two values are the same object. By contrast, = compares only the numeric values of the objects.

At present, each integer value has a unique Lisp object in Emacs Lisp. Therefore, eq is equivalent to = where integers are concerned. It is sometimes convenient to use eq for comparing an unknown value with an integer, because eq does not report an error if the unknown value is not a number—it accepts arguments of any type. By contrast, = signals an error if the arguments are not numbers or markers. However, it is a good idea to use = if you can, even for comparing integers, just in case we change the representation of integers in a future Emacs version.

Sometimes it is useful to compare numbers with equal; it treats two numbers as equal if they have the same data type (both integers, or both floating point) and the same value. By contrast, = can treat an integer and a floating point number as equal. See 相等判定.

There is another wrinkle: because floating point arithmetic is not exact, it is often a bad idea to check for equality of two floating point values. Usually it is better to test for approximate equality. Here's a function to do this:

     (defvar fuzz-factor 1.0e-6)
     (defun approx-equal (x y)
       (or (and (= x 0) (= y 0))
           (< (/ (abs (- x y))
                 (max (abs x) (abs y)))
              fuzz-factor)))

Common Lisp note: Comparing numbers in Common Lisp always requires = because Common Lisp implements multi-word integers, and two distinct integer objects can have the same numeric value. Emacs Lisp can have just one integer object for any given value because it has a limited range of integer values.

3.5 Numeric Conversions

To convert an integer to floating point, use the function float.

There are four functions to convert floating point numbers to integers; they differ in how they round. All accept an argument number and an optional argument divisor. Both arguments may be integers or floating point numbers. divisor may also be nil. If divisor is nil or omitted, these functions convert number to an integer, or return it unchanged if it already is an integer. If divisor is non-nil, they divide number by divisor and convert the result to an integer. An arith-error results if divisor is 0.

3.6 Arithmetic Operations

Emacs Lisp provides the traditional four arithmetic operations: addition, subtraction, multiplication, and division. Remainder and modulus functions supplement the division functions. The functions to add or subtract 1 are provided because they are traditional in Lisp and commonly used.

All of these functions except % return a floating point value if any argument is floating.

It is important to note that in Emacs Lisp, arithmetic functions do not check for overflow. Thus (1+ 268435455) may evaluate to −268435456, depending on your hardware.

3.7 Rounding Operations

The functions ffloor, fceiling, fround, and ftruncate take a floating point argument and return a floating point result whose value is a nearby integer. ffloor returns the nearest integer below; fceiling, the nearest integer above; ftruncate, the nearest integer in the direction towards zero; fround, the nearest integer.

3.8 Bitwise Operations on Integers

In a computer, an integer is represented as a binary number, a sequence of bits (digits which are either zero or one). A bitwise operation acts on the individual bits of such a sequence. For example, shifting moves the whole sequence left or right one or more places, reproducing the same pattern “moved over.”

The bitwise operations in Emacs Lisp apply only to integers.

3.9 Standard Mathematical Functions

These mathematical functions allow integers as well as floating point numbers as arguments.

3.10 Random Numbers

A deterministic computer program cannot generate true random numbers. For most purposes, pseudo-random numbers suffice. A series of pseudo-random numbers is generated in a deterministic fashion. The numbers are not truly random, but they have certain properties that mimic a random series. For example, all possible values occur equally often in a pseudo-random series.

In Emacs, pseudo-random numbers are generated from a “seed” number. Starting from any given seed, the random function always generates the same sequence of numbers. Emacs always starts with the same seed value, so the sequence of values of random is actually the same in each Emacs run! For example, in one operating system, the first call to (random) after you start Emacs always returns −1457731, and the second one always returns −7692030. This repeatability is helpful for debugging.

If you want random numbers that don't always come out the same, execute (random t). This chooses a new seed based on the current time of day and on Emacs's process ID number.

4 Strings and Characters

A string in Emacs Lisp is an array that contains an ordered sequence of characters. Strings are used as names of symbols, buffers, and files; to send messages to users; to hold text being copied between buffers; and for many other purposes. Because strings are so important, Emacs Lisp has many functions expressly for manipulating them. Emacs Lisp programs use strings more often than individual characters.

See Strings of Events, for special considerations for strings of keyboard character events.

• Basics: Basic properties of strings and characters.
• Predicates for Strings: Testing whether an object is a string or char.
• Creating Strings: Functions to allocate new strings.
• Modifying Strings: Altering the contents of an existing string.
• Text Comparison: Comparing characters or strings.
• String Conversion: Converting to and from characters and strings.
• Formatting Strings: format: Emacs's analogue of printf.
• Case Conversion: Case conversion functions.
• Case Tables: Customizing case conversion.

4.1 String and Character Basics

Characters are represented in Emacs Lisp as integers; whether an integer is a character or not is determined only by how it is used. Thus, strings really contain integers. See Character Codes, for details about character representation in Emacs.

The length of a string (like any array) is fixed, and cannot be altered once the string exists. Strings in Lisp are not terminated by a distinguished character code. (By contrast, strings in C are terminated by a character with ASCII code 0.)

Since strings are arrays, and therefore sequences as well, you can operate on them with the general array and sequence functions. (See Sequences Arrays Vectors.) For example, you can access or change individual characters in a string using the functions aref and aset (see Array Functions).

There are two text representations for non-ASCII characters in Emacs strings (and in buffers): unibyte and multibyte (see Text Representations). For most Lisp programming, you don't need to be concerned with these two representations.

Sometimes key sequences are represented as unibyte strings. When a unibyte string is a key sequence, string elements in the range 128 to 255 represent meta characters (which are large integers) rather than character codes in the range 128 to 255. Strings cannot hold characters that have the hyper, super or alt modifiers; they can hold ASCII control characters, but no other control characters. They do not distinguish case in ASCII control characters. If you want to store such characters in a sequence, such as a key sequence, you must use a vector instead of a string. See 字符类型, for more information about keyboard input characters.

Strings are useful for holding regular expressions. You can also match regular expressions against strings with string-match (see Regexp Search). The functions match-string (see Simple Match Data) and replace-match (see Replacing Match) are useful for decomposing and modifying strings after matching regular expressions against them.

Like a buffer, a string can contain text properties for the characters in it, as well as the characters themselves. See Text Properties. All the Lisp primitives that copy text from strings to buffers or other strings also copy the properties of the characters being copied.

See Text, for information about functions that display strings or copy them into buffers. See 字符类型, and 字符串类型, for information about the syntax of characters and strings. See Non-ASCII Characters, for functions to convert between text representations and to encode and decode character codes.

4.2 The Predicates for Strings

For more information about general sequence and array predicates, see Sequences Arrays Vectors, and Arrays.

4.3 Creating Strings

The following functions create strings, either from scratch, or by putting strings together, or by taking them apart.

4.4 Modifying Strings

The most basic way to alter the contents of an existing string is with aset (see Array Functions). (aset string idx char) stores char into string at index idx. Each character occupies one or more bytes, and if char needs a different number of bytes from the character already present at that index, aset signals an error.

A more powerful function is store-substring:

To clear out a string that contained a password, use clear-string:

4.5 Comparison of Characters and Strings

See also the function compare-buffer-substrings in Comparing Text, for a way to compare text in buffers. The function string-match, which matches a regular expression against a string, can be used for a kind of string comparison; see Regexp Search.

4.6 Conversion of Characters and Strings

This section describes functions for converting between characters, strings and integers. format (see Formatting Strings) and prin1-to-string (see Output Functions) can also convert Lisp objects into strings. read-from-string (see Input Functions) can “convert” a string representation of a Lisp object into an object. The functions string-make-multibyte and string-make-unibyte convert the text representation of a string (see Converting Representations).

See Documentation, for functions that produce textual descriptions of text characters and general input events (single-key-description and text-char-description). These are used primarily for making help messages.

Here are some other functions that can convert to or from a string:

concat

This function converts a vector or a list into a string. See Creating Strings.

vconcat

This function converts a string into a vector. See Vector Functions.

append

This function converts a string into a list. See Building Lists.

byte-to-string

This function converts a byte of character data into a unibyte string. See Converting Representations.

4.7 Formatting Strings

Formatting means constructing a string by substituting computed values at various places in a constant string. This constant string controls how the other values are printed, as well as where they appear; it is called a format string.

Formatting is often useful for computing messages to be displayed. In fact, the functions message and error provide the same formatting feature described here; they differ from format only in how they use the result of formatting.

A format specification is a sequence of characters beginning with a ‘%’. Thus, if there is a ‘%d’ in string, the format function replaces it with the printed representation of one of the values to be formatted (one of the arguments objects). For example:

     (format "The value of fill-column is %d." fill-column)
          ⇒ "The value of fill-column is 72."

Since format interprets ‘%’ characters as format specifications, you should never pass an arbitrary string as the first argument. This is particularly true when the string is generated by some Lisp code. Unless the string is known to never include any ‘%’ characters, pass "%s", described below, as the first argument, and the string as the second, like this:

       (format "%s" arbitrary-string)

If string contains more than one format specification, the format specifications correspond to successive values from objects. Thus, the first format specification in string uses the first such value, the second format specification uses the second such value, and so on. Any extra format specifications (those for which there are no corresponding values) cause an error. Any extra values to be formatted are ignored.

Certain format specifications require values of particular types. If you supply a value that doesn't fit the requirements, an error is signaled.

Here is a table of valid format specifications:

‘%s’

Replace the specification with the printed representation of the object, made without quoting (that is, using princ, not prin1—see Output Functions). Thus, strings are represented by their contents alone, with no ‘"’ characters, and symbols appear without ‘\’ characters.

If the object is a string, its text properties are copied into the output. The text properties of the ‘%s’ itself are also copied, but those of the object take priority.

‘%S’

Replace the specification with the printed representation of the object, made with quoting (that is, using prin1—see Output Functions). Thus, strings are enclosed in ‘"’ characters, and ‘\’ characters appear where necessary before special characters.

‘%o’

Replace the specification with the base-eight representation of an integer.

‘%d’

Replace the specification with the base-ten representation of an integer.

‘%x’

‘%X’

Replace the specification with the base-sixteen representation of an integer. ‘%x’ uses lower case and ‘%X’ uses upper case.

‘%c’

Replace the specification with the character which is the value given.

‘%e’

Replace the specification with the exponential notation for a floating point number.

‘%f’

Replace the specification with the decimal-point notation for a floating point number.

‘%g’

Replace the specification with notation for a floating point number, using either exponential notation or decimal-point notation, whichever is shorter.

‘%%’

Replace the specification with a single ‘%’. This format specification is unusual in that it does not use a value. For example, (format "%% %d" 30) returns "% 30".

Any other format character results in an ‘Invalid format operation’ error.

Here are several examples:

     (format "The name of this buffer is %s." (buffer-name))
          ⇒ "The name of this buffer is strings.texi."
     
     (format "The buffer object prints as %s." (current-buffer))
          ⇒ "The buffer object prints as strings.texi."
     
     (format "The octal value of %d is %o,
              and the hex value is %x." 18 18 18)
          ⇒ "The octal value of 18 is 22,
              and the hex value is 12."

A specification can have a width, which is a decimal number between the ‘%’ and the specification character. If the printed representation of the object contains fewer characters than this width, format extends it with padding. The width specifier is ignored for the ‘%%’ specification. Any padding introduced by the width specifier normally consists of spaces inserted on the left:

     (format "%5d is padded on the left with spaces" 123)
          ⇒ "  123 is padded on the left with spaces"

If the width is too small, format does not truncate the object's printed representation. Thus, you can use a width to specify a minimum spacing between columns with no risk of losing information. In the following three examples, ‘%7s’ specifies a minimum width of 7. In the first case, the string inserted in place of ‘%7s’ has only 3 letters, and needs 4 blank spaces as padding. In the second case, the string "specification" is 13 letters wide but is not truncated.

     (format "The word `%7s' actually has %d letters in it."
             "foo" (length "foo"))
          ⇒ "The word `    foo' actually has 3 letters in it."
     (format "The word `%7s' actually has %d letters in it."
             "specification" (length "specification"))
          ⇒ "The word `specification' actually has 13 letters in it."

Immediately after the ‘%’ and before the optional width specifier, you can also put certain flag characters.

The flag ‘+’ inserts a plus sign before a positive number, so that it always has a sign. A space character as flag inserts a space before a positive number. (Otherwise, positive numbers start with the first digit.) These flags are useful for ensuring that positive numbers and negative numbers use the same number of columns. They are ignored except for ‘%d’, ‘%e’, ‘%f’, ‘%g’, and if both flags are used, ‘+’ takes precedence.

The flag ‘#’ specifies an “alternate form” which depends on the format in use. For ‘%o’, it ensures that the result begins with a ‘0’. For ‘%x’ and ‘%X’, it prefixes the result with ‘0x’ or ‘0X’. For ‘%e’, ‘%f’, and ‘%g’, the ‘#’ flag means include a decimal point even if the precision is zero.